{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "40dcf5d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sys import path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "a84669e6",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/home/huang/python_code/2023',\n",
       " '/home/huang/anaconda3/lib/python39.zip',\n",
       " '/home/huang/anaconda3/lib/python3.9',\n",
       " '/home/huang/anaconda3/lib/python3.9/lib-dynload',\n",
       " '',\n",
       " '/home/huang/anaconda3/lib/python3.9/site-packages',\n",
       " '/home/huang/anaconda3/lib/python3.9/site-packages/IPython/extensions',\n",
       " '/home/huang/.ipython']"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "50c78324",
   "metadata": {},
   "outputs": [],
   "source": [
    "path.append(\"/home/huang/Documents/packaging_tutorial/src/\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "1946a9df",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/home/huang/python_code/2023',\n",
       " '/home/huang/anaconda3/lib/python39.zip',\n",
       " '/home/huang/anaconda3/lib/python3.9',\n",
       " '/home/huang/anaconda3/lib/python3.9/lib-dynload',\n",
       " '',\n",
       " '/home/huang/anaconda3/lib/python3.9/site-packages',\n",
       " '/home/huang/anaconda3/lib/python3.9/site-packages/IPython/extensions',\n",
       " '/home/huang/.ipython',\n",
       " '/home/huang/Documents/packaging_tutorial/src/']"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "680941de",
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext autoreload \n",
    "%autoreload 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9a40dbc3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy import *\n",
    "from sympy.abc import x,y,z,a,b,c,t,k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "15f3e0b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - a + x - \\log{\\left(x \\right)} + \\frac{e^{x}}{x}$"
      ],
      "text/plain": [
       "-a + x - log(x) + exp(x)/x"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=exp(x)/x-ln(x)+x-a\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2b0b8d82",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(x - 1\\right) \\left(x + e^{x}\\right)}{x^{2}}$"
      ],
      "text/plain": [
       "(x - 1)*(x + exp(x))/x**2"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(cancel(diff(expr+a,x)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "d4e27fdf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(x - 1\\right) \\left(x e^{\\frac{1}{x}} + 1\\right)}{x^{2}}$"
      ],
      "text/plain": [
       "(x - 1)*(x*exp(1/x) + 1)/x**2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(simplify(expr.subs(x,1/x))+a,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "90dbc098",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(x - 1\\right) e^{\\frac{1}{x}}}{x}$"
      ],
      "text/plain": [
       "(x - 1)*exp(1/x)/x"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(x*exp(1/x),x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d7dc6020",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd5a4c44af0>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(x*exp(1/x)+1,x+exp(x),(x,0.5,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "76a264cd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(k + x\\right) \\log{\\left(x \\right)}}{x - 1}$"
      ],
      "text/plain": [
       "(k + x)*log(x)/(x - 1)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=(x+k)/(x-1)*ln(x)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7c2dd5ff",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- k x \\log{\\left(x \\right)} + k x - k + x^{2} - x \\log{\\left(x \\right)} - x}{x \\left(x - 1\\right)^{2}}$"
      ],
      "text/plain": [
       "(-k*x*log(x) + k*x - k + x**2 - x*log(x) - x)/(x*(x - 1)**2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(diff(expr,x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d87b17c5",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0$"
      ],
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(factor(diff(expr,x)).args[2]+(k+1)*x*ln(x)-(x+k)*(x-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "bf059400",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{\\sqrt{\\left(k + 1\\right) \\left(- 4 k + e k + e\\right)} e^{\\frac{1}{2}}}{2} + \\frac{- 2 k + e k + e}{2}, \\frac{\\sqrt{\\left(k + 1\\right) \\left(- 4 k + e k + e\\right)} e^{\\frac{1}{2}}}{2} + \\frac{- 2 k + e k + e}{2}\\right\\}$"
      ],
      "text/plain": [
       "{-sqrt((k + 1)*(-4*k + E*k + E))*exp(1/2)/2 + (-2*k + E*k + E)/2, sqrt((k + 1)*(-4*k + E*k + E))*exp(1/2)/2 + (-2*k + E*k + E)/2}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(exp(1)*x-(x+k)**2/(k+1),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b3101be1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\left(x + e \\left(-2 + e\\right)\\right) \\log{\\left(x \\right)}}{x - 1}$"
      ],
      "text/plain": [
       "(x + E*(-2 + E))*log(x)/(x - 1)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_check=expr.subs(k,exp(1)*(exp(1)-2))\n",
    "expr_check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "43b38fd8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd594483280>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr_check,exp(1),(x,1,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "831c9dec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd594425610>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(exp(1)*x,((x+k)**2/(k+1)).subs(k,exp(1)/(4-exp(1))),(x,2,2.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "78fcbce7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{True}$"
      ],
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp(1)/(4-exp(1))+1>exp(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "6e6986a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(1/a**2-1/b**2)/(1/a+1/b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b91d71a8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{1}{b} + \\frac{1}{a}$"
      ],
      "text/plain": [
       "-1/b + 1/a"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(simplify(expr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "e36264ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(- \\sqrt{2} + \\sqrt{3}\\right)^{2}$"
      ],
      "text/plain": [
       "(-sqrt(2) + sqrt(3))**2"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=((sqrt(3)-sqrt(2))**2)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e2ec5770",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 5 - 2 \\sqrt{6}$"
      ],
      "text/plain": [
       "5 - 2*sqrt(6)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "427b49fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( 21, \\  6\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(21, 6)}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linsolve([3*(y+1)-x,2*y-(x-9)],[x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e08c64ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y=symbols(\"x,y\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "adce7ad0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- \\sqrt{x} \\sqrt{y} + x - 2 y}{y}$"
      ],
      "text/plain": [
       "(-sqrt(x)*sqrt(y) + x - 2*y)/y"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=(x-sqrt(x*y)-2*y)/y\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "ec521a53",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- \\sqrt{x} \\sqrt{y} + x - 2 y}{y}$"
      ],
      "text/plain": [
       "(-sqrt(x)*sqrt(y) + x - 2*y)/y"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(sqrt(x/y),t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "49982c22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{x\\; \\middle|\\; x \\in \\mathbb{R} \\wedge 3 \\cdot 2^{4 x} + 2 \\cdot 3^{4 x} - 5 \\cdot 6^{2 x} = 0 \\right\\}$"
      ],
      "text/plain": [
       "ConditionSet(x, Eq(3*2**(4*x) + 2*3**(4*x) - 5*6**(2*x), 0), Reals)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(3*16**x+2*81**x-5*36**x,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "fb182598",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "112.669177789704\n",
      "113.0\n",
      "126.94343623807929\n",
      "126.0\n",
      "143.02612586744107\n",
      "139.0\n"
     ]
    }
   ],
   "source": [
    "for i in range(10,31,10):\n",
    "    print(100*(1+1.2/100)**i)\n",
    "    print(100+i*1.3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "4de3230c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class range in module builtins:\n",
      "\n",
      "class range(object)\n",
      " |  range(stop) -> range object\n",
      " |  range(start, stop[, step]) -> range object\n",
      " |  \n",
      " |  Return an object that produces a sequence of integers from start (inclusive)\n",
      " |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      " |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      " |  These are exactly the valid indices for a list of 4 elements.\n",
      " |  When step is given, it specifies the increment (or decrement).\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      True if self else False\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      Return a reverse iterator.\n",
      " |  \n",
      " |  count(...)\n",
      " |      rangeobject.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  index(...)\n",
      " |      rangeobject.index(value) -> integer -- return index of value.\n",
      " |      Raise ValueError if the value is not present.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  start\n",
      " |  \n",
      " |  step\n",
      " |  \n",
      " |  stop\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(range)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "e9441ce4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a^{x} k$"
      ],
      "text/plain": [
       "a**x*k"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=k*a**x\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "302df5f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( - \\frac{3}{4}, \\  -128\\right), \\left( \\frac{3}{4}, \\  128\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(-3/4, -128), (3/4, 128)}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([Eq(96,expr.subs(x,1)),Eq(54,expr.subs(x,3))],[a,k])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "29593274",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{81}{2}$"
      ],
      "text/plain": [
       "81/2"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs([(a,Rational(3,4)),(k,128)]).subs(x,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "4e02d564",
   "metadata": {},
   "outputs": [],
   "source": [
    "f=2**x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5b9c445b",
   "metadata": {},
   "outputs": [],
   "source": [
    "g=lambda x: 2**x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "2da22785",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "fc8aac97",
   "metadata": {},
   "outputs": [],
   "source": [
    "func=Piecewise((0,(x<=0)),(f,(x<=1)),(2*g(x-1)+1,True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6d645a4d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} 2^{x} & \\text{for}\\: x \\leq 1 \\\\2 \\cdot 2^{x - 1} + 1 & \\text{otherwise} \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise((2**x, x <= 1), (2*2**(x - 1) + 1, True))"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "14dba67a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{1}{2}$"
      ],
      "text/plain": [
       "1/2"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func.subs(x,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "9d69ae2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import n,m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7e98be7f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{1\\right\\} \\cup \\left(\\left\\{1, 2, \\ldots, 10\\right\\} \\setminus \\left\\{1\\right\\}\\right)$"
      ],
      "text/plain": [
       "Union(Complement(Range(1, 11, 1), Range(1, 2, 1)), Range(1, 2, 1))"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(func.subs(x,n)<2023,n,Naturals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "12d5b234",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5120000000000001"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.8**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "92f13a96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-1 + \\frac{2 \\left(- \\cos{\\left(x \\right)} + \\sqrt{2}\\right)^{2}}{- 2 \\sqrt{2} \\cos{\\left(x \\right)} + 3}\\right)^{2} \\cdot \\left(2 \\sqrt{2} \\cos{\\left(x \\right)} + 3\\right) = \\left(\\sqrt{2} \\cos{\\left(x \\right)} + 1\\right)^{2}$"
      ],
      "text/plain": [
       "Eq((-1 + 2*(-cos(x) + sqrt(2))**2/(-2*sqrt(2)*cos(x) + 3))**2*(2*sqrt(2)*cos(x) + 3), (sqrt(2)*cos(x) + 1)**2)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq1=Eq((3+2*sqrt(2)*cos(x))*(2*(sqrt(2)-cos(x))**2/(3-2*sqrt(2)*cos(x))-1)**2,(1+sqrt(2)*cos(x))**2)\n",
    "eq1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "f62f8428",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-1, 1, \\frac{3 \\sqrt{2}}{2}, - \\frac{3 \\sqrt{2} \\cdot \\left(\\frac{11}{4} - \\frac{11 \\sqrt{17}}{12}\\right)}{22} + \\frac{3 \\sqrt{2}}{4}, - \\frac{3 \\sqrt{2} \\cdot \\left(\\frac{11}{4} + \\frac{11 \\sqrt{17}}{12}\\right)}{22} + \\frac{3 \\sqrt{2}}{4}\\right\\}$"
      ],
      "text/plain": [
       "{-1, 1, 3*sqrt(2)/2, -3*sqrt(2)*(11/4 - 11*sqrt(17)/12)/22 + 3*sqrt(2)/4, -3*sqrt(2)*(11/4 + 11*sqrt(17)/12)/22 + 3*sqrt(2)/4}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(eq1,cos(x),Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "48616e26",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=list(solveset(eq1,cos(x),Reals))[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "25d0b4a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -0.198538900965752$"
      ],
      "text/plain": [
       "-0.198538900965752"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "fb1e189f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{\\frac{9}{2} - \\frac{\\sqrt{17}}{2}}$"
      ],
      "text/plain": [
       "sqrt(9/2 - sqrt(17)/2)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(simplify(3+2*sqrt(2)*answer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "85d065bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 4 \\sin^{3}{\\left(x \\right)} + 3 \\sin{\\left(x \\right)}$"
      ],
      "text/plain": [
       "-4*sin(x)**3 + 3*sin(x)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand_trig(sin(3*x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "cd269ffd",
   "metadata": {},
   "outputs": [],
   "source": [
    "eq2=Eq(Rational(3,2)-sqrt(2)*cos(x),((sqrt(2)+1/sqrt(2))/(4*(cos(y))**2-1))**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "fed0604b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\sqrt{2} \\cos{\\left(x \\right)} + \\frac{3}{2} = \\frac{9}{2 \\left(4 \\cos^{2}{\\left(y \\right)} - 1\\right)^{2}}$"
      ],
      "text/plain": [
       "Eq(-sqrt(2)*cos(x) + 3/2, 9/(2*(4*cos(y)**2 - 1)**2))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "2e683ba8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\sqrt{2} \\cos{\\left(x \\right)} + \\frac{3}{2} = \\frac{9}{2 \\left(-1 + \\frac{2 \\sqrt{2} \\cos{\\left(x \\right)} + 3}{- \\sqrt{2} \\cos{\\left(x \\right)} + \\frac{3}{2}}\\right)^{2}}$"
      ],
      "text/plain": [
       "Eq(-sqrt(2)*cos(x) + 3/2, 9/(2*(-1 + (2*sqrt(2)*cos(x) + 3)/(-sqrt(2)*cos(x) + 3/2))**2))"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq3=eq2.subs(4*(cos(y))**2,(3+2*sqrt(2)*cos(x))/(Rational(3,2)-sqrt(2)*cos(x)))\n",
    "eq3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "156c96f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{- \\frac{3 \\sqrt{2} \\cdot \\left(\\frac{13}{4} - \\frac{13 \\sqrt{17}}{12}\\right)}{26}, - \\frac{3 \\sqrt{2} \\cdot \\left(\\frac{13}{4} + \\frac{13 \\sqrt{17}}{12}\\right)}{26}\\right\\}$"
      ],
      "text/plain": [
       "{-3*sqrt(2)*(13/4 - 13*sqrt(17)/12)/26, -3*sqrt(2)*(13/4 + 13*sqrt(17)/12)/26}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(eq3,cos(x),Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "7a73e756",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 0.198538900965752$"
      ],
      "text/plain": [
       "0.198538900965752"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N(list(solveset(eq3,cos(x),Reals))[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "5d339c30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\emptyset$"
      ],
      "text/plain": [
       "EmptySet"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([a**(-1)+b+1,a**0+b],[a,b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "10398985",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function plot_implicit in module sympy.plotting.plot_implicit:\n",
      "\n",
      "plot_implicit(expr, x_var=None, y_var=None, adaptive=True, depth=0, points=300, line_color='blue', show=True, **kwargs)\n",
      "    A plot function to plot implicit equations / inequalities.\n",
      "    \n",
      "    Arguments\n",
      "    =========\n",
      "    \n",
      "    - ``expr`` : The equation / inequality that is to be plotted.\n",
      "    - ``x_var`` (optional) : symbol to plot on x-axis or tuple giving symbol\n",
      "      and range as ``(symbol, xmin, xmax)``\n",
      "    - ``y_var`` (optional) : symbol to plot on y-axis or tuple giving symbol\n",
      "      and range as ``(symbol, ymin, ymax)``\n",
      "    \n",
      "    If neither ``x_var`` nor ``y_var`` are given then the free symbols in the\n",
      "    expression will be assigned in the order they are sorted.\n",
      "    \n",
      "    The following keyword arguments can also be used:\n",
      "    \n",
      "    - ``adaptive`` Boolean. The default value is set to True. It has to be\n",
      "        set to False if you want to use a mesh grid.\n",
      "    \n",
      "    - ``depth`` integer. The depth of recursion for adaptive mesh grid.\n",
      "        Default value is 0. Takes value in the range (0, 4).\n",
      "    \n",
      "    - ``points`` integer. The number of points if adaptive mesh grid is not\n",
      "        used. Default value is 300.\n",
      "    \n",
      "    - ``show`` Boolean. Default value is True. If set to False, the plot will\n",
      "        not be shown. See ``Plot`` for further information.\n",
      "    \n",
      "    - ``title`` string. The title for the plot.\n",
      "    \n",
      "    - ``xlabel`` string. The label for the x-axis\n",
      "    \n",
      "    - ``ylabel`` string. The label for the y-axis\n",
      "    \n",
      "    Aesthetics options:\n",
      "    \n",
      "    - ``line_color``: float or string. Specifies the color for the plot.\n",
      "        See ``Plot`` to see how to set color for the plots.\n",
      "        Default value is \"Blue\"\n",
      "    \n",
      "    plot_implicit, by default, uses interval arithmetic to plot functions. If\n",
      "    the expression cannot be plotted using interval arithmetic, it defaults to\n",
      "    a generating a contour using a mesh grid of fixed number of points. By\n",
      "    setting adaptive to False, you can force plot_implicit to use the mesh\n",
      "    grid. The mesh grid method can be effective when adaptive plotting using\n",
      "    interval arithmetic, fails to plot with small line width.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    Plot expressions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: reset\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> from sympy import plot_implicit, symbols, Eq, And\n",
      "        >>> x, y = symbols('x y')\n",
      "    \n",
      "    Without any ranges for the symbols in the expression:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p1 = plot_implicit(Eq(x**2 + y**2, 5))\n",
      "    \n",
      "    With the range for the symbols:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p2 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 3), (x, -3, 3), (y, -3, 3))\n",
      "    \n",
      "    With depth of recursion as argument:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p3 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -4, 4), (y, -4, 4), depth = 2)\n",
      "    \n",
      "    Using mesh grid and not using adaptive meshing:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p4 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),\n",
      "        ...     adaptive=False)\n",
      "    \n",
      "    Using mesh grid without using adaptive meshing with number of points\n",
      "    specified:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p5 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),\n",
      "        ...     adaptive=False, points=400)\n",
      "    \n",
      "    Plotting regions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p6 = plot_implicit(y > x**2)\n",
      "    \n",
      "    Plotting Using boolean conjunctions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p7 = plot_implicit(And(y > x, y > -x))\n",
      "    \n",
      "    When plotting an expression with a single variable (y - 1, for example),\n",
      "    specify the x or the y variable explicitly:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p8 = plot_implicit(y - 1, y_var=y)\n",
      "        >>> p9 = plot_implicit(x - 1, x_var=x)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plot_implicit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3b2b2df5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1=plot_implicit(And(-2<x+y, x+y<4,2<2*x-y,2*x-y<8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "f3107cff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd594310190>"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2=plot(-x/2)\n",
    "p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d0fc8c57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1.extend(p2)\n",
    "p1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "59082120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function plot_implicit in module sympy.plotting.plot_implicit:\n",
      "\n",
      "plot_implicit(expr, x_var=None, y_var=None, adaptive=True, depth=0, points=300, line_color='blue', show=True, **kwargs)\n",
      "    A plot function to plot implicit equations / inequalities.\n",
      "    \n",
      "    Arguments\n",
      "    =========\n",
      "    \n",
      "    - ``expr`` : The equation / inequality that is to be plotted.\n",
      "    - ``x_var`` (optional) : symbol to plot on x-axis or tuple giving symbol\n",
      "      and range as ``(symbol, xmin, xmax)``\n",
      "    - ``y_var`` (optional) : symbol to plot on y-axis or tuple giving symbol\n",
      "      and range as ``(symbol, ymin, ymax)``\n",
      "    \n",
      "    If neither ``x_var`` nor ``y_var`` are given then the free symbols in the\n",
      "    expression will be assigned in the order they are sorted.\n",
      "    \n",
      "    The following keyword arguments can also be used:\n",
      "    \n",
      "    - ``adaptive`` Boolean. The default value is set to True. It has to be\n",
      "        set to False if you want to use a mesh grid.\n",
      "    \n",
      "    - ``depth`` integer. The depth of recursion for adaptive mesh grid.\n",
      "        Default value is 0. Takes value in the range (0, 4).\n",
      "    \n",
      "    - ``points`` integer. The number of points if adaptive mesh grid is not\n",
      "        used. Default value is 300.\n",
      "    \n",
      "    - ``show`` Boolean. Default value is True. If set to False, the plot will\n",
      "        not be shown. See ``Plot`` for further information.\n",
      "    \n",
      "    - ``title`` string. The title for the plot.\n",
      "    \n",
      "    - ``xlabel`` string. The label for the x-axis\n",
      "    \n",
      "    - ``ylabel`` string. The label for the y-axis\n",
      "    \n",
      "    Aesthetics options:\n",
      "    \n",
      "    - ``line_color``: float or string. Specifies the color for the plot.\n",
      "        See ``Plot`` to see how to set color for the plots.\n",
      "        Default value is \"Blue\"\n",
      "    \n",
      "    plot_implicit, by default, uses interval arithmetic to plot functions. If\n",
      "    the expression cannot be plotted using interval arithmetic, it defaults to\n",
      "    a generating a contour using a mesh grid of fixed number of points. By\n",
      "    setting adaptive to False, you can force plot_implicit to use the mesh\n",
      "    grid. The mesh grid method can be effective when adaptive plotting using\n",
      "    interval arithmetic, fails to plot with small line width.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    Plot expressions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: reset\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> from sympy import plot_implicit, symbols, Eq, And\n",
      "        >>> x, y = symbols('x y')\n",
      "    \n",
      "    Without any ranges for the symbols in the expression:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p1 = plot_implicit(Eq(x**2 + y**2, 5))\n",
      "    \n",
      "    With the range for the symbols:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p2 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 3), (x, -3, 3), (y, -3, 3))\n",
      "    \n",
      "    With depth of recursion as argument:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p3 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -4, 4), (y, -4, 4), depth = 2)\n",
      "    \n",
      "    Using mesh grid and not using adaptive meshing:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p4 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),\n",
      "        ...     adaptive=False)\n",
      "    \n",
      "    Using mesh grid without using adaptive meshing with number of points\n",
      "    specified:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p5 = plot_implicit(\n",
      "        ...     Eq(x**2 + y**2, 5), (x, -5, 5), (y, -2, 2),\n",
      "        ...     adaptive=False, points=400)\n",
      "    \n",
      "    Plotting regions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p6 = plot_implicit(y > x**2)\n",
      "    \n",
      "    Plotting Using boolean conjunctions:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p7 = plot_implicit(And(y > x, y > -x))\n",
      "    \n",
      "    When plotting an expression with a single variable (y - 1, for example),\n",
      "    specify the x or the y variable explicitly:\n",
      "    \n",
      "    .. plot::\n",
      "        :context: close-figs\n",
      "        :format: doctest\n",
      "        :include-source: True\n",
      "    \n",
      "        >>> p8 = plot_implicit(y - 1, y_var=y)\n",
      "        >>> p9 = plot_implicit(x - 1, x_var=x)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(plot_implicit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "a19b7d6f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1=plot_implicit(x**2+y**2-x*y/2-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "1eff9818",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p2=plot_implicit(x**2+y**2<Rational(4,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "1d5562ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1.extend(p2)\n",
    "p1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "2d4abbcc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1=plot_implicit(And(0<x-y,x-y<2,2<x+y,x+y<4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "90b3d30c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p2=plot(-3*x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "49bbf4de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1.extend(p2)\n",
    "p1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "1312b472",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1=plot_implicit(And(6*x+3*y>24,4*x+5*y<22))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "5f88b6ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p2=plot(2*x/3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "4d14a011",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "p1.extend(p2)\n",
    "p1.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "04364b55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linsolve in module sympy.solvers.solveset:\n",
      "\n",
      "linsolve(system, *symbols)\n",
      "    Solve system of $N$ linear equations with $M$ variables; both\n",
      "    underdetermined and overdetermined systems are supported.\n",
      "    The possible number of solutions is zero, one or infinite.\n",
      "    Zero solutions throws a ValueError, whereas infinite\n",
      "    solutions are represented parametrically in terms of the given\n",
      "    symbols. For unique solution a :class:`~.FiniteSet` of ordered tuples\n",
      "    is returned.\n",
      "    \n",
      "    All standard input formats are supported:\n",
      "    For the given set of equations, the respective input types\n",
      "    are given below:\n",
      "    \n",
      "    .. math:: 3x + 2y -   z = 1\n",
      "    .. math:: 2x - 2y + 4z = -2\n",
      "    .. math:: 2x -   y + 2z = 0\n",
      "    \n",
      "    * Augmented matrix form, ``system`` given below:\n",
      "    \n",
      "    $$ \\text{system} = \\left[{array}{cccc}\n",
      "        3 &  2 & -1 &  1\\\\\n",
      "        2 & -2 &  4 & -2\\\\\n",
      "        2 & -1 &  2 &  0\n",
      "        \\end{array}\\right] $$\n",
      "    \n",
      "    ::\n",
      "    \n",
      "        system = Matrix([[3, 2, -1, 1], [2, -2, 4, -2], [2, -1, 2, 0]])\n",
      "    \n",
      "    * List of equations form\n",
      "    \n",
      "    ::\n",
      "    \n",
      "        system  =  [3x + 2y - z - 1, 2x - 2y + 4z + 2, 2x - y + 2z]\n",
      "    \n",
      "    * Input $A$ and $b$ in matrix form (from $Ax = b$) are given as:\n",
      "    \n",
      "    $$ A = \\left[\\begin{array}{ccc}\n",
      "        3 &  2 & -1 \\\\\n",
      "        2 & -2 &  4 \\\\\n",
      "        2 & -1 &  2\n",
      "        \\end{array}\\right] \\ \\  b = \\left[\\begin{array}{c}\n",
      "        1 \\\\ -2 \\\\ 0\n",
      "        \\end{array}\\right] $$\n",
      "    \n",
      "    ::\n",
      "    \n",
      "        A = Matrix([[3, 2, -1], [2, -2, 4], [2, -1, 2]])\n",
      "        b = Matrix([[1], [-2], [0]])\n",
      "        system = (A, b)\n",
      "    \n",
      "    Symbols can always be passed but are actually only needed\n",
      "    when 1) a system of equations is being passed and 2) the\n",
      "    system is passed as an underdetermined matrix and one wants\n",
      "    to control the name of the free variables in the result.\n",
      "    An error is raised if no symbols are used for case 1, but if\n",
      "    no symbols are provided for case 2, internally generated symbols\n",
      "    will be provided. When providing symbols for case 2, there should\n",
      "    be at least as many symbols are there are columns in matrix A.\n",
      "    \n",
      "    The algorithm used here is Gauss-Jordan elimination, which\n",
      "    results, after elimination, in a row echelon form matrix.\n",
      "    \n",
      "    Returns\n",
      "    =======\n",
      "    \n",
      "    A FiniteSet containing an ordered tuple of values for the\n",
      "    unknowns for which the `system` has a solution. (Wrapping\n",
      "    the tuple in FiniteSet is used to maintain a consistent\n",
      "    output format throughout solveset.)\n",
      "    \n",
      "    Returns EmptySet, if the linear system is inconsistent.\n",
      "    \n",
      "    Raises\n",
      "    ======\n",
      "    \n",
      "    ValueError\n",
      "        The input is not valid.\n",
      "        The symbols are not given.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import Matrix, linsolve, symbols\n",
      "    >>> x, y, z = symbols(\"x, y, z\")\n",
      "    >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 10]])\n",
      "    >>> b = Matrix([3, 6, 9])\n",
      "    >>> A\n",
      "    Matrix([\n",
      "    [1, 2,  3],\n",
      "    [4, 5,  6],\n",
      "    [7, 8, 10]])\n",
      "    >>> b\n",
      "    Matrix([\n",
      "    [3],\n",
      "    [6],\n",
      "    [9]])\n",
      "    >>> linsolve((A, b), [x, y, z])\n",
      "    {(-1, 2, 0)}\n",
      "    \n",
      "    * Parametric Solution: In case the system is underdetermined, the\n",
      "      function will return a parametric solution in terms of the given\n",
      "      symbols. Those that are free will be returned unchanged. e.g. in\n",
      "      the system below, `z` is returned as the solution for variable z;\n",
      "      it can take on any value.\n",
      "    \n",
      "    >>> A = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\n",
      "    >>> b = Matrix([3, 6, 9])\n",
      "    >>> linsolve((A, b), x, y, z)\n",
      "    {(z - 1, 2 - 2*z, z)}\n",
      "    \n",
      "    If no symbols are given, internally generated symbols will be used.\n",
      "    The ``tau0`` in the third position indicates (as before) that the third\n",
      "    variable -- whatever it is named -- can take on any value:\n",
      "    \n",
      "    >>> linsolve((A, b))\n",
      "    {(tau0 - 1, 2 - 2*tau0, tau0)}\n",
      "    \n",
      "    * List of equations as input\n",
      "    \n",
      "    >>> Eqns = [3*x + 2*y - z - 1, 2*x - 2*y + 4*z + 2, - x + y/2 - z]\n",
      "    >>> linsolve(Eqns, x, y, z)\n",
      "    {(1, -2, -2)}\n",
      "    \n",
      "    * Augmented matrix as input\n",
      "    \n",
      "    >>> aug = Matrix([[2, 1, 3, 1], [2, 6, 8, 3], [6, 8, 18, 5]])\n",
      "    >>> aug\n",
      "    Matrix([\n",
      "    [2, 1,  3, 1],\n",
      "    [2, 6,  8, 3],\n",
      "    [6, 8, 18, 5]])\n",
      "    >>> linsolve(aug, x, y, z)\n",
      "    {(3/10, 2/5, 0)}\n",
      "    \n",
      "    * Solve for symbolic coefficients\n",
      "    \n",
      "    >>> a, b, c, d, e, f = symbols('a, b, c, d, e, f')\n",
      "    >>> eqns = [a*x + b*y - c, d*x + e*y - f]\n",
      "    >>> linsolve(eqns, x, y)\n",
      "    {((-b*f + c*e)/(a*e - b*d), (a*f - c*d)/(a*e - b*d))}\n",
      "    \n",
      "    * A degenerate system returns solution as set of given\n",
      "      symbols.\n",
      "    \n",
      "    >>> system = Matrix(([0, 0, 0], [0, 0, 0], [0, 0, 0]))\n",
      "    >>> linsolve(system, x, y)\n",
      "    {(x, y)}\n",
      "    \n",
      "    * For an empty system linsolve returns empty set\n",
      "    \n",
      "    >>> linsolve([], x)\n",
      "    EmptySet\n",
      "    \n",
      "    * An error is raised if, after expansion, any nonlinearity\n",
      "      is detected:\n",
      "    \n",
      "    >>> linsolve([x*(1/x - 1), (y - 1)**2 - y**2 + 1], x, y)\n",
      "    {(1, 1)}\n",
      "    >>> linsolve([x**2 - 1], x)\n",
      "    Traceback (most recent call last):\n",
      "    ...\n",
      "    NonlinearError:\n",
      "    nonlinear term encountered: x**2\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(linsolve)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "47e7dd97",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}6 & 4\\\\3 & 5\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[6, 4],\n",
       "[3, 5]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=Matrix([[6,4],[3,5]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "d6016213",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[\\begin{matrix}2\\\\-3\\end{matrix}\\right]$"
      ],
      "text/plain": [
       "Matrix([\n",
       "[ 2],\n",
       "[-3]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=Matrix([2,-3])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "45924264",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "89edb939",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( \\frac{11}{9}, \\  - \\frac{4}{3}\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(11/9, -4/3)}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linsolve((A,b),[x,y])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "cac00c7d",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Unequality in module sympy.core.relational:\n",
      "\n",
      "class Unequality(Relational)\n",
      " |  Unequality(lhs, rhs, **options)\n",
      " |  \n",
      " |  An unequal relation between two objects.\n",
      " |  \n",
      " |  Explanation\n",
      " |  ===========\n",
      " |  \n",
      " |  Represents that two objects are not equal.  If they can be shown to be\n",
      " |  definitively equal, this will reduce to False; if definitively unequal,\n",
      " |  this will reduce to True.  Otherwise, the relation is maintained as an\n",
      " |  Unequality object.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Ne\n",
      " |  >>> from sympy.abc import x, y\n",
      " |  >>> Ne(y, x+x**2)\n",
      " |  Ne(y, x**2 + x)\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  Equality\n",
      " |  \n",
      " |  Notes\n",
      " |  =====\n",
      " |  This class is not the same as the != operator.  The != operator tests\n",
      " |  for exact structural equality between two expressions; this class\n",
      " |  compares expressions mathematically.\n",
      " |  \n",
      " |  This class is effectively the inverse of Equality.  As such, it uses the\n",
      " |  same algorithms, including any available `_eval_Eq` methods.\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Unequality\n",
      " |      Relational\n",
      " |      sympy.logic.boolalg.Boolean\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, lhs, rhs, **options)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  binary_symbols\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  rel_op = '!='\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Relational:\n",
      " |  \n",
      " |  __bool__(self)\n",
      " |  \n",
      " |  equals(self, other, failing_expression=False)\n",
      " |      Return True if the sides of the relationship are mathematically\n",
      " |      identical and the type of relationship is the same.\n",
      " |      If failing_expression is True, return the expression whose truth value\n",
      " |      was unknown.\n",
      " |  \n",
      " |  expand(self, **kwargs)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from Relational:\n",
      " |  \n",
      " |  canonical\n",
      " |      Return a canonical form of the relational by putting a\n",
      " |      number on the rhs, canonically removing a sign or else\n",
      " |      ordering the args canonically. No other simplification is\n",
      " |      attempted.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x < 2\n",
      " |      x < 2\n",
      " |      >>> _.reversed.canonical\n",
      " |      x < 2\n",
      " |      >>> (-y < x).canonical\n",
      " |      x > -y\n",
      " |      >>> (-y > x).canonical\n",
      " |      x < -y\n",
      " |      >>> (-y < -x).canonical\n",
      " |      x < y\n",
      " |      \n",
      " |      The canonicalization is recursively applied:\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> Eq(x < y, y > x).canonical\n",
      " |      True\n",
      " |  \n",
      " |  lhs\n",
      " |      The left-hand side of the relation.\n",
      " |  \n",
      " |  negated\n",
      " |      Return the negated relationship.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Eq(x, 1)\n",
      " |      Eq(x, 1)\n",
      " |      >>> _.negated\n",
      " |      Ne(x, 1)\n",
      " |      >>> x < 1\n",
      " |      x < 1\n",
      " |      >>> _.negated\n",
      " |      x >= 1\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      This works more or less identical to ``~``/``Not``. The difference is\n",
      " |      that ``negated`` returns the relationship even if ``evaluate=False``.\n",
      " |      Hence, this is useful in code when checking for e.g. negated relations\n",
      " |      to existing ones as it will not be affected by the `evaluate` flag.\n",
      " |  \n",
      " |  reversed\n",
      " |      Return the relationship with sides reversed.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Eq(x, 1)\n",
      " |      Eq(x, 1)\n",
      " |      >>> _.reversed\n",
      " |      Eq(1, x)\n",
      " |      >>> x < 1\n",
      " |      x < 1\n",
      " |      >>> _.reversed\n",
      " |      1 > x\n",
      " |  \n",
      " |  reversedsign\n",
      " |      Return the relationship with signs reversed.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Eq\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Eq(x, 1)\n",
      " |      Eq(x, 1)\n",
      " |      >>> _.reversedsign\n",
      " |      Eq(-x, -1)\n",
      " |      >>> x < 1\n",
      " |      x < 1\n",
      " |      >>> _.reversedsign\n",
      " |      -x > -1\n",
      " |  \n",
      " |  rhs\n",
      " |      The right-hand side of the relation.\n",
      " |  \n",
      " |  strict\n",
      " |      return the strict version of the inequality or self\n",
      " |      \n",
      " |      EXAMPLES\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (x <= 1).strict\n",
      " |      x < 1\n",
      " |      >>> _.strict\n",
      " |      x < 1\n",
      " |  \n",
      " |  weak\n",
      " |      return the non-strict version of the inequality or self\n",
      " |      \n",
      " |      EXAMPLES\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> (x < 1).weak\n",
      " |      x <= 1\n",
      " |      >>> _.weak\n",
      " |      x <= 1\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Relational:\n",
      " |  \n",
      " |  ValidRelationOperator = {None: <class 'sympy.core.relational.Equality'...\n",
      " |  \n",
      " |  is_Relational = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.logic.boolalg.Boolean:\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __invert__(self)\n",
      " |      Overloading for ~\n",
      " |  \n",
      " |  __lshift__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |  \n",
      " |  __rand__ = __and__(self, other)\n",
      " |  \n",
      " |  __rlshift__ = __rshift__(self, other)\n",
      " |  \n",
      " |  __ror__ = __or__(self, other)\n",
      " |  \n",
      " |  __rrshift__ = __lshift__(self, other)\n",
      " |  \n",
      " |  __rshift__(self, other)\n",
      " |  \n",
      " |  __rxor__ = __xor__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  as_set(self)\n",
      " |      Rewrites Boolean expression in terms of real sets.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol, Eq, Or, And\n",
      " |      >>> x = Symbol('x', real=True)\n",
      " |      >>> Eq(x, 0).as_set()\n",
      " |      {0}\n",
      " |      >>> (x > 0).as_set()\n",
      " |      Interval.open(0, oo)\n",
      " |      >>> And(-2 < x, x < 2).as_set()\n",
      " |      Interval.open(-2, 2)\n",
      " |      >>> Or(x < -2, 2 < x).as_set()\n",
      " |      Union(Interval.open(-oo, -2), Interval.open(2, oo))\n",
      " |  \n",
      " |  to_nnf(self, simplify=True)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.logic.boolalg.Boolean:\n",
      " |  \n",
      " |  kind = BooleanKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'tuple[Basic, ...]', '_mhash': 'int | None...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Ne)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "14582902",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x^{3} + x^{2} y - 2 x y^{2} - y^{3}$"
      ],
      "text/plain": [
       "2*x**3 + x**2*y - 2*x*y**2 - y**3"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=(2*x**3-y**3)-(2*x*y**2-x**2*y)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "11cbf520",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(x - y\\right) \\left(x + y\\right) \\left(2 x + y\\right)$"
      ],
      "text/plain": [
       "(x - y)*(x + y)*(2*x + y)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(expr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "ffc703d9",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=x**2-2*y+1\n",
    "b=y**2-2*z+2\n",
    "c=z**2-2*x+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "2f8b2aab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} - 2 x + y^{2} - 2 y + z^{2} - 2 z + 5$"
      ],
      "text/plain": [
       "x**2 - 2*x + y**2 - 2*y + z**2 - 2*z + 5"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(a+b+c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "2a0f803b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} - 2 x + y^{2} - 2 y + z^{2} - 2 z + 5$"
      ],
      "text/plain": [
       "x**2 - 2*x + y**2 - 2*y + z**2 - 2*z + 5"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "together(a+b+c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "754247bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.calculus.util import continuous_domain,function_range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "a357961f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\emptyset$"
      ],
      "text/plain": [
       "EmptySet"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "continuous_domain(sqrt(1-3**x),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "665e56e3",
   "metadata": {},
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "\nUnable to find range for the given domain.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3921/3327160444.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunction_range\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mReals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/calculus/util.py\u001b[0m in \u001b[0;36mfunction_range\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    170\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    171\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 172\u001b[0;31m             raise NotImplementedError(filldedent('''\n\u001b[0m\u001b[1;32m    173\u001b[0m                 \u001b[0mUnable\u001b[0m \u001b[0mto\u001b[0m \u001b[0mfind\u001b[0m \u001b[0mrange\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mgiven\u001b[0m \u001b[0mdomain\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    174\u001b[0m                 '''))\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: \nUnable to find range for the given domain."
     ]
    }
   ],
   "source": [
    "function_range(sqrt(1-3**x),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8db82210",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=2**(1/(x-4))\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82c22db8",
   "metadata": {},
   "outputs": [],
   "source": [
    "continuous_domain(expr,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "888844ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_range(1/(x-4),x,continuous_domain(expr,x,Reals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "441d63ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_range(2**x,x,function_range(1/(x-4),x,continuous_domain(expr,x,Reals)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f758cf86",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr.subs(x,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c10df0c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_range(expr,x,Interval.Ropen(-oo,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a78e8bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afe60c61",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(limit)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e36c8526",
   "metadata": {},
   "source": [
    "### 这里有一个非常大的错误！！！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "fe5ec311",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\infty$"
      ],
      "text/plain": [
       "oo"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(2**(1/x),x,0,dir=\"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "a048e9f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -\\infty$"
      ],
      "text/plain": [
       "-oo"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Limit(1/x,x,0,dir=\"-\").doit()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "5d1a795b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\lim_{x \\to 0^-} 3^{\\frac{1}{x}}$"
      ],
      "text/plain": [
       "Limit(3**(1/x), x, 0, dir='-')"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Limit(3**(1/x),x,0,dir=\"-\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d444f5a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "function_range(1/(5**x-1),x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43ce41c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(2-m)*x**2-2*(m-2)*x+4\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca85d6b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "solveset(expr,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "400b32ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=symbols(\"a\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1eb89a4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(a**2-4)*x**2+(a+2)*x-1\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74148513",
   "metadata": {},
   "outputs": [],
   "source": [
    "solveset(expr,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ed1f327",
   "metadata": {},
   "outputs": [],
   "source": [
    "solveset(x**2+(a-4)*x+4-2*a>0,a,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a1aa36b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.solvers.inequalities import solve_univariate_inequality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "518815bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "solve_univariate_inequality(x**2+(a-4)*x+4-2*a>0,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70993ed2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.solvers.inequalities import reduce_abs_inequalities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21d5abde",
   "metadata": {},
   "outputs": [],
   "source": [
    "simplify(reduce_abs_inequalities([(abs(x-2)-1,'>')],x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1827aaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=(1+x**2)/(1+2*sqrt(2)*x)\n",
    "expr\n",
    "\n",
    "apart(expr)\n",
    "\n",
    "expr=x+2*sqrt(x)+3\n",
    "expr\n",
    "\n",
    "expr=(x**2+17)/(4*sqrt(1+x**2))\n",
    "expr\n",
    "\n",
    "function_range(expr,x,Reals)\n",
    "\n",
    "help(apart)\n",
    "\n",
    "expand(expr)\n",
    "\n",
    "x,y=symbols(\"x,y\",positive=True)\n",
    "\n",
    "eq1=Eq(x+y+2/x+6/y,10)\n",
    "eq1\n",
    "\n",
    "p1=plot_implicit(eq1,(x,0,10),(y,0,10))\n",
    "\n",
    "p2=plot_implicit(2/x-5/y)\n",
    "\n",
    "p1.extend(p2)\n",
    "p1.show()\n",
    "\n",
    "help(plot_implicit)\n",
    "\n",
    "exp(4.605)\n",
    "\n",
    "x=symbols(\"x\")\n",
    "\n",
    "expr=Piecewise((2**x,x<=0),(abs(log(x,2)),True))\n",
    "expr\n",
    "\n",
    "solveset(expr.subs(x,expr)-1,x,Reals)\n",
    "\n",
    "(27-Rational(1,27))/(3-Rational(1,3))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "a1e9a5f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y=symbols(\"x,y\",positive=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "aa71bf76",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd58ff44c10>"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot_implicit(x+y-x*y-1,(x,0,10),(y,0,10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "26a2f1ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1336336"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "34**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "54fec6f2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + 3 x + 2$"
      ],
      "text/plain": [
       "x**2 + 3*x + 2"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=x**2+3*x+2\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "16e8a0e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[- \\frac{1}{4}, 42\\right]$"
      ],
      "text/plain": [
       "Interval(-1/4, 42)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(expr,x,Interval(-5,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "4f3c0dd0",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function radsimp in module sympy.simplify.radsimp:\n",
      "\n",
      "radsimp(expr, symbolic=True, max_terms=4)\n",
      "    Rationalize the denominator by removing square roots.\n",
      "    \n",
      "    Explanation\n",
      "    ===========\n",
      "    \n",
      "    The expression returned from radsimp must be used with caution\n",
      "    since if the denominator contains symbols, it will be possible to make\n",
      "    substitutions that violate the assumptions of the simplification process:\n",
      "    that for a denominator matching a + b*sqrt(c), a != +/-b*sqrt(c). (If\n",
      "    there are no symbols, this assumptions is made valid by collecting terms\n",
      "    of sqrt(c) so the match variable ``a`` does not contain ``sqrt(c)``.) If\n",
      "    you do not want the simplification to occur for symbolic denominators, set\n",
      "    ``symbolic`` to False.\n",
      "    \n",
      "    If there are more than ``max_terms`` radical terms then the expression is\n",
      "    returned unchanged.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import radsimp, sqrt, Symbol, pprint\n",
      "    >>> from sympy import factor_terms, fraction, signsimp\n",
      "    >>> from sympy.simplify.radsimp import collect_sqrt\n",
      "    >>> from sympy.abc import a, b, c\n",
      "    \n",
      "    >>> radsimp(1/(2 + sqrt(2)))\n",
      "    (2 - sqrt(2))/2\n",
      "    >>> x,y = map(Symbol, 'xy')\n",
      "    >>> e = ((2 + 2*sqrt(2))*x + (2 + sqrt(8))*y)/(2 + sqrt(2))\n",
      "    >>> radsimp(e)\n",
      "    sqrt(2)*(x + y)\n",
      "    \n",
      "    No simplification beyond removal of the gcd is done. One might\n",
      "    want to polish the result a little, however, by collecting\n",
      "    square root terms:\n",
      "    \n",
      "    >>> r2 = sqrt(2)\n",
      "    >>> r5 = sqrt(5)\n",
      "    >>> ans = radsimp(1/(y*r2 + x*r2 + a*r5 + b*r5)); pprint(ans)\n",
      "        ___       ___       ___       ___\n",
      "      \\/ 5 *a + \\/ 5 *b - \\/ 2 *x - \\/ 2 *y\n",
      "    ------------------------------------------\n",
      "       2               2      2              2\n",
      "    5*a  + 10*a*b + 5*b  - 2*x  - 4*x*y - 2*y\n",
      "    \n",
      "    >>> n, d = fraction(ans)\n",
      "    >>> pprint(factor_terms(signsimp(collect_sqrt(n))/d, radical=True))\n",
      "            ___             ___\n",
      "          \\/ 5 *(a + b) - \\/ 2 *(x + y)\n",
      "    ------------------------------------------\n",
      "       2               2      2              2\n",
      "    5*a  + 10*a*b + 5*b  - 2*x  - 4*x*y - 2*y\n",
      "    \n",
      "    If radicals in the denominator cannot be removed or there is no denominator,\n",
      "    the original expression will be returned.\n",
      "    \n",
      "    >>> radsimp(sqrt(2)*x + sqrt(2))\n",
      "    sqrt(2)*x + sqrt(2)\n",
      "    \n",
      "    Results with symbols will not always be valid for all substitutions:\n",
      "    \n",
      "    >>> eq = 1/(a + b*sqrt(c))\n",
      "    >>> eq.subs(a, b*sqrt(c))\n",
      "    1/(2*b*sqrt(c))\n",
      "    >>> radsimp(eq).subs(a, b*sqrt(c))\n",
      "    nan\n",
      "    \n",
      "    If ``symbolic=False``, symbolic denominators will not be transformed (but\n",
      "    numeric denominators will still be processed):\n",
      "    \n",
      "    >>> radsimp(eq, symbolic=False)\n",
      "    1/(a + b*sqrt(c))\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(radsimp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "3c26fa4e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + 3 x + 2$"
      ],
      "text/plain": [
       "x**2 + 3*x + 2"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collect(expr,(x-1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "c5f86755",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} - x \\left(2 k + 2\\right) + 3$"
      ],
      "text/plain": [
       "x**2 - x*(2*k + 2) + 3"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=x**2-2*(k+1)*x+3\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "8471f18f",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{k - \\sqrt{k^{2} + 2 k - 2} + 1, k + \\sqrt{k^{2} + 2 k - 2} + 1\\right\\}$"
      ],
      "text/plain": [
       "Intersection({k - sqrt(k**2 + 2*k - 2) + 1, k + sqrt(k**2 + 2*k - 2) + 1}, Reals)"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(expr,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "ee7b8146",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 k + 11$"
      ],
      "text/plain": [
       "4*k + 11"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "7583e3f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 - 4 k$"
      ],
      "text/plain": [
       "3 - 4*k"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "d6a40077",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - k^{2} - 2 k + 2$"
      ],
      "text/plain": [
       "-k**2 - 2*k + 2"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expand(expr.subs(x,k+1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "9f185467",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle m x + n + 2 x^{2}$"
      ],
      "text/plain": [
       "m*x + n + 2*x**2"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=2*x**2+m*x+n\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "1825af67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle n = -1$"
      ],
      "text/plain": [
       "Eq(n, -1)"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq1=Eq(expr.subs(x,0),-1)\n",
    "eq1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "77d4f517",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle m x + 2 x^{2} - 1$"
      ],
      "text/plain": [
       "m*x + 2*x**2 - 1"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr1=expr.subs(n,-1)\n",
    "expr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "01bc4180",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1 - m = 2 m + 7$"
      ],
      "text/plain": [
       "Eq(1 - m, 2*m + 7)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq2=Eq(expr1.subs(x,-1),expr1.subs(x,2))\n",
    "eq2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "1eca850e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-2\\right\\}$"
      ],
      "text/plain": [
       "{-2}"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(eq2,m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "6b0089e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x^{2} - 2 x - 1$"
      ],
      "text/plain": [
       "2*x**2 - 2*x - 1"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr2=expr1.subs(m,-2)\n",
    "expr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "bb8f263c",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd5944412e0>"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr2,(x,-3,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "3332e1f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b=symbols(\"a,b\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "7ac6da5d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a^{2} + 6 a + 3$"
      ],
      "text/plain": [
       "2*a**2 + 6*a + 3"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr2.subs(x,a+2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "4c5f4dc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{3}{2}$"
      ],
      "text/plain": [
       "-3/2"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr2.subs(x,Rational(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "299e2018",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a^{2} - 2 a - 1$"
      ],
      "text/plain": [
       "2*a**2 - 2*a - 1"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr2.subs(x,a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "e3345ff7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 a x + x^{2}$"
      ],
      "text/plain": [
       "-2*a*x + x**2"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=x**2-2*a*x\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "d2a81625",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - 2 a \\left(2 a - 2\\right) + \\left(2 a - 2\\right)^{2}$"
      ],
      "text/plain": [
       "-2*a*(2*a - 2) + (2*a - 2)**2"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,(a-1)*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "5d5354b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{2\\right\\}$"
      ],
      "text/plain": [
       "{2}"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(Eq(expr.subs(x,(a-1)*2),-4),a,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "be2f435b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[1, 10\\right]$"
      ],
      "text/plain": [
       "Interval(1, 10)"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(x**2-2*x+2,x,Interval(-2,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "c09156ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "f=lambda x: 4*x*(x-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "e0753a4d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 x \\left(x - 1\\right)$"
      ],
      "text/plain": [
       "4*x*(x - 1)"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a19a3082",
   "metadata": {},
   "source": [
    "#### 不知道Piecewise该如何递归！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "d64b6c62",
   "metadata": {},
   "outputs": [],
   "source": [
    "x=symbols(\"x\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "301a358d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} 4 x \\left(x - 1\\right) & \\text{for}\\: x \\leq 1 \\wedge x > 0 \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise((4*x*(x - 1), (x <= 1) & (x > 0)))"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g=Piecewise((f(x),(0<x) & (x<=1)))\n",
    "g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "3d4e3da2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} \\frac{\\begin{cases} 4 x \\left(x + 1\\right) & \\text{for}\\: x \\leq 0 \\wedge x > -1 \\end{cases}}{3} & \\text{for}\\: x \\leq 0 \\\\4 x \\left(x - 1\\right) & \\text{for}\\: x \\leq 1 \\\\3 \\left(\\begin{cases} 4 \\left(x - 2\\right) \\left(x - 1\\right) & \\text{for}\\: x \\leq 2 \\wedge x > 1 \\end{cases}\\right) & \\text{otherwise} \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise((Piecewise((4*x*(x + 1), (x <= 0) & (x > -1)))/3, x <= 0), (4*x*(x - 1), x <= 1), (3*Piecewise((4*(x - 2)*(x - 1), (x <= 2) & (x > 1))), True))"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h=Piecewise((g.subs(x,x+1)/3,x<=0),(f(x),(0<x) & (x<=1)),(g.subs(x,x-1)*3,True))\n",
    "h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "f2566a5e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\text{NaN}$"
      ],
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.subs(x,-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "eeea48b9",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "Don't know how to calculate the mrv of '(4*(-3 + 1/_p)*(-2 + 1/_p), (1/_p <= 3) & (1/_p > 2))'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3921/3566890354.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunction_range\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mg\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mInterval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mLopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/calculus/util.py\u001b[0m in \u001b[0;36mfunction_range\u001b[0;34m(f, symbol, domain)\u001b[0m\n\u001b[1;32m    188\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mis_open\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlimit_point\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdirection\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mbounds\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    189\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mis_open\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 190\u001b[0;31m                     \u001b[0mcritical_values\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mFiniteSet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msymbol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlimit_point\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdirection\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    191\u001b[0m                     \u001b[0mvals\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mcritical_values\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    192\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/limits.py\u001b[0m in \u001b[0;36mlimit\u001b[0;34m(e, z, z0, dir)\u001b[0m\n\u001b[1;32m     62\u001b[0m     \"\"\"\n\u001b[1;32m     63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mLimit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdoit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdeep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/limits.py\u001b[0m in \u001b[0;36mdoit\u001b[0;34m(self, **hints)\u001b[0m\n\u001b[1;32m    360\u001b[0m                             % (l, r))\n\u001b[1;32m    361\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 362\u001b[0;31m                 \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgruntz\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    363\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mr\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNaN\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNaN\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    364\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0mPoleError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/gruntz.py\u001b[0m in \u001b[0;36mgruntz\u001b[0;34m(e, z, z0, dir)\u001b[0m\n\u001b[1;32m    709\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    710\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 711\u001b[0;31m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlimitinf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    712\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    713\u001b[0m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlimitinf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mleadsimp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/cache.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m                 \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'unhashable type:'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/gruntz.py\u001b[0m in \u001b[0;36mlimitinf\u001b[0;34m(e, x, leadsimp)\u001b[0m\n\u001b[1;32m    450\u001b[0m     \u001b[0me\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrewrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'tractable'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdeep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlimitvar\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    451\u001b[0m     \u001b[0me\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpowdenest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 452\u001b[0;31m     \u001b[0mc0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0me0\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmrv_leadterm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    453\u001b[0m     \u001b[0msig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msign\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    454\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0msig\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/cache.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m                 \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'unhashable type:'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/gruntz.py\u001b[0m in \u001b[0;36mmrv_leadterm\u001b[0;34m(e, x)\u001b[0m\n\u001b[1;32m    525\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mZero\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    526\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mOmega\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mSubsSet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 527\u001b[0;31m         \u001b[0mOmega\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexps\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmrv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    528\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mOmega\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    529\u001b[0m         \u001b[0;31m# e really does not depend on x after simplification\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/gruntz.py\u001b[0m in \u001b[0;36mmrv\u001b[0;34m(e, x)\u001b[0m\n\u001b[1;32m    304\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    305\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_Function\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 306\u001b[0;31m         \u001b[0ml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mmrv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    307\u001b[0m         \u001b[0ml2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0ms\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ms\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mSubsSet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    308\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/gruntz.py\u001b[0m in \u001b[0;36m<listcomp>\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m    304\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    305\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_Function\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 306\u001b[0;31m         \u001b[0ml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mmrv\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ma\u001b[0m \u001b[0;32min\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    307\u001b[0m         \u001b[0ml2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0ms\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0m_\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0ms\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mSubsSet\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    308\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/gruntz.py\u001b[0m in \u001b[0;36mmrv\u001b[0;34m(e, x)\u001b[0m\n\u001b[1;32m    316\u001b[0m         raise NotImplementedError(\"MRV set computation for derviatives\"\n\u001b[1;32m    317\u001b[0m                                   \" not implemented yet.\")\n\u001b[0;32m--> 318\u001b[0;31m     raise NotImplementedError(\n\u001b[0m\u001b[1;32m    319\u001b[0m         \"Don't know how to calculate the mrv of '%s'\" % e)\n\u001b[1;32m    320\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: Don't know how to calculate the mrv of '(4*(-3 + 1/_p)*(-2 + 1/_p), (1/_p <= 3) & (1/_p > 2))'"
     ]
    }
   ],
   "source": [
    "function_range(g,x,Interval.Lopen(-2,0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "5c447361",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "id": "b1fc49ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "x**2 + 2*x + 1\n"
     ]
    }
   ],
   "source": [
    " %aimport quadratic_function.base "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "87942b32",
   "metadata": {},
   "outputs": [],
   "source": [
    "from quadratic_function.base import quadratic_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "9e2fac6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle m x + n + 2 x^{2}$"
      ],
      "text/plain": [
       "m*x + n + 2*x**2"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=quadratic_function(2,m,n)\n",
    "q.to_expr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "id": "120ea261",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-2\\right\\}$"
      ],
      "text/plain": [
       "{-2}"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(Eq(q.symmetry,(-2+S(3))/2),m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "70414a62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle n = -1$"
      ],
      "text/plain": [
       "Eq(n, -1)"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Eq(q.to_expr().subs(x,1),-1).subs(m,-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "id": "1cb2ba99",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd57f65f370>"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(2*x**2-2*x-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "id": "e88140a5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x^{2} - 2 x - 1$"
      ],
      "text/plain": [
       "2*x**2 - 2*x - 1"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=2*x**2-2*x-1\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "id": "dd05cb37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a^{2} + 6 a + 3$"
      ],
      "text/plain": [
       "2*a**2 + 6*a + 3"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr.subs(x,a+2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "id": "9cbcd8a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 a^{2} - 2 a - 1$"
      ],
      "text/plain": [
       "2*a**2 - 2*a - 1"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr.subs(x,a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "id": "f5827a1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{3}{2}$"
      ],
      "text/plain": [
       "-3/2"
      ]
     },
     "execution_count": 203,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr.subs(x,Rational(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "5a73fbb8",
   "metadata": {},
   "outputs": [],
   "source": [
    "q=quadratic_function(S(-1),S(24),S(-16))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "b8a8f8ca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 128 - \\left(x - 12\\right)^{2}$"
      ],
      "text/plain": [
       "128 - (x - 12)**2"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.to_symmetry_expr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "c1bfe708",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{- x^{2} + 24 x - 16}{x}$"
      ],
      "text/plain": [
       "(-x**2 + 24*x - 16)/x"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.to_expr()/x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "bd213914",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3}{a + 1} + \\frac{1}{b}$"
      ],
      "text/plain": [
       "3/(a + 1) + 1/b"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=3/(a+1)+1/b\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "903b094b",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr_t=expr.subs(b,1-a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "0023a779",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3}{a + 1} + \\frac{1}{1 - a}$"
      ],
      "text/plain": [
       "3/(a + 1) + 1/(1 - a)"
      ]
     },
     "execution_count": 213,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr_t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "4bdf8bd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=function_range(expr_t,a,Interval.open(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "id": "0b2c644d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{3} + 2$"
      ],
      "text/plain": [
       "sqrt(3) + 2"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(answer.left)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "0964d6a2",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Interval in module sympy.sets.sets:\n",
      "\n",
      "class Interval(Set)\n",
      " |  Interval(start, end, left_open=False, right_open=False)\n",
      " |  \n",
      " |  Represents a real interval as a Set.\n",
      " |  \n",
      " |  Usage:\n",
      " |      Returns an interval with end points ``start`` and ``end``.\n",
      " |  \n",
      " |      For ``left_open=True`` (default ``left_open`` is ``False``) the interval\n",
      " |      will be open on the left. Similarly, for ``right_open=True`` the interval\n",
      " |      will be open on the right.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Symbol, Interval\n",
      " |  >>> Interval(0, 1)\n",
      " |  Interval(0, 1)\n",
      " |  >>> Interval.Ropen(0, 1)\n",
      " |  Interval.Ropen(0, 1)\n",
      " |  >>> Interval.Ropen(0, 1)\n",
      " |  Interval.Ropen(0, 1)\n",
      " |  >>> Interval.Lopen(0, 1)\n",
      " |  Interval.Lopen(0, 1)\n",
      " |  >>> Interval.open(0, 1)\n",
      " |  Interval.open(0, 1)\n",
      " |  \n",
      " |  >>> a = Symbol('a', real=True)\n",
      " |  >>> Interval(0, a)\n",
      " |  Interval(0, a)\n",
      " |  \n",
      " |  Notes\n",
      " |  =====\n",
      " |  - Only real end points are supported\n",
      " |  - ``Interval(a, b)`` with $a > b$ will return the empty set\n",
      " |  - Use the ``evalf()`` method to turn an Interval into an mpmath\n",
      " |    ``mpi`` interval instance\n",
      " |  \n",
      " |  References\n",
      " |  ==========\n",
      " |  \n",
      " |  .. [1] https://en.wikipedia.org/wiki/Interval_%28mathematics%29\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Interval\n",
      " |      Set\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  as_relational(self, x)\n",
      " |      Rewrite an interval in terms of inequalities and logic operators.\n",
      " |  \n",
      " |  to_mpi(self, prec=53)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  Lopen(a, b) from sympy.core.assumptions.ManagedProperties\n",
      " |      Return an interval not including the left boundary.\n",
      " |  \n",
      " |  Ropen(a, b) from sympy.core.assumptions.ManagedProperties\n",
      " |      Return an interval not including the right boundary.\n",
      " |  \n",
      " |  open(a, b) from sympy.core.assumptions.ManagedProperties\n",
      " |      Return an interval including neither boundary.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, start, end, left_open=False, right_open=False)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  end\n",
      " |      The right end point of the interval.\n",
      " |      \n",
      " |      This property takes the same value as the ``sup`` property.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).end\n",
      " |      1\n",
      " |  \n",
      " |  is_empty\n",
      " |  \n",
      " |  is_finite_set\n",
      " |  \n",
      " |  is_left_unbounded\n",
      " |      Return ``True`` if the left endpoint is negative infinity.\n",
      " |  \n",
      " |  is_right_unbounded\n",
      " |      Return ``True`` if the right endpoint is positive infinity.\n",
      " |  \n",
      " |  left\n",
      " |  \n",
      " |  left_open\n",
      " |      True if interval is left-open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1, left_open=True).left_open\n",
      " |      True\n",
      " |      >>> Interval(0, 1, left_open=False).left_open\n",
      " |      False\n",
      " |  \n",
      " |  right\n",
      " |  \n",
      " |  right_open\n",
      " |      True if interval is right-open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1, right_open=True).right_open\n",
      " |      True\n",
      " |      >>> Interval(0, 1, right_open=False).right_open\n",
      " |      False\n",
      " |  \n",
      " |  start\n",
      " |      The left end point of the interval.\n",
      " |      \n",
      " |      This property takes the same value as the ``inf`` property.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).start\n",
      " |      0\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  is_Interval = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Set:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __contains__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |  \n",
      " |  __pow__(self, exp)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  complement(self, universe)\n",
      " |      The complement of 'self' w.r.t the given universe.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(0, 1).complement(S.Reals)\n",
      " |      Union(Interval.open(-oo, 0), Interval.open(1, oo))\n",
      " |      \n",
      " |      >>> Interval(0, 1).complement(S.UniversalSet)\n",
      " |      Complement(UniversalSet, Interval(0, 1))\n",
      " |  \n",
      " |  contains(self, other)\n",
      " |      Returns a SymPy value indicating whether ``other`` is contained\n",
      " |      in ``self``: ``true`` if it is, ``false`` if it is not, else\n",
      " |      an unevaluated ``Contains`` expression (or, as in the case of\n",
      " |      ConditionSet and a union of FiniteSet/Intervals, an expression\n",
      " |      indicating the conditions for containment).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(0.5)\n",
      " |      True\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``in`` operator, but that\n",
      " |      will raise an error unless an affirmative true or false is not\n",
      " |      obtained.\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(x)\n",
      " |      (0 <= x) & (x <= 1)\n",
      " |      >>> x in Interval(0, 1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      TypeError: did not evaluate to a bool: None\n",
      " |      \n",
      " |      The result of 'in' is a bool, not a SymPy value\n",
      " |      \n",
      " |      >>> 1 in Interval(0, 2)\n",
      " |      True\n",
      " |      >>> _ is S.true\n",
      " |      False\n",
      " |  \n",
      " |  intersect(self, other)\n",
      " |      Returns the intersection of 'self' and 'other'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      \n",
      " |      >>> Interval(1, 3).intersect(Interval(1, 2))\n",
      " |      Interval(1, 2)\n",
      " |      \n",
      " |      >>> from sympy import imageset, Lambda, symbols, S\n",
      " |      >>> n, m = symbols('n m')\n",
      " |      >>> a = imageset(Lambda(n, 2*n), S.Integers)\n",
      " |      >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))\n",
      " |      EmptySet\n",
      " |  \n",
      " |  intersection(self, other)\n",
      " |      Alias for :meth:`intersect()`\n",
      " |  \n",
      " |  is_disjoint(self, other)\n",
      " |      Returns True if ``self`` and ``other`` are disjoint.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(1, 2))\n",
      " |      False\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(3, 4))\n",
      " |      True\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Disjoint_sets\n",
      " |  \n",
      " |  is_proper_subset(self, other)\n",
      " |      Returns True if ``self`` is a proper subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_subset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_proper_superset(self, other)\n",
      " |      Returns True if ``self`` is a proper superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_subset(self, other)\n",
      " |      Returns True if ``self`` is a subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))\n",
      " |      False\n",
      " |  \n",
      " |  is_superset(self, other)\n",
      " |      Returns True if ``self`` is a superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_superset(Interval(0, 1))\n",
      " |      False\n",
      " |      >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))\n",
      " |      True\n",
      " |  \n",
      " |  isdisjoint(self, other)\n",
      " |      Alias for :meth:`is_disjoint()`\n",
      " |  \n",
      " |  issubset(self, other)\n",
      " |      Alias for :meth:`is_subset()`\n",
      " |  \n",
      " |  issuperset(self, other)\n",
      " |      Alias for :meth:`is_superset()`\n",
      " |  \n",
      " |  powerset(self)\n",
      " |      Find the Power set of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import EmptySet, FiniteSet, Interval\n",
      " |      \n",
      " |      A power set of an empty set:\n",
      " |      \n",
      " |      >>> A = EmptySet\n",
      " |      >>> A.powerset()\n",
      " |      {EmptySet}\n",
      " |      \n",
      " |      A power set of a finite set:\n",
      " |      \n",
      " |      >>> A = FiniteSet(1, 2)\n",
      " |      >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)\n",
      " |      >>> A.powerset() == FiniteSet(a, b, c, EmptySet)\n",
      " |      True\n",
      " |      \n",
      " |      A power set of an interval:\n",
      " |      \n",
      " |      >>> Interval(1, 2).powerset()\n",
      " |      PowerSet(Interval(1, 2))\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Power_set\n",
      " |  \n",
      " |  symmetric_difference(self, other)\n",
      " |      Returns symmetric difference of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(1, 3).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(3, oo))\n",
      " |      >>> Interval(1, 10).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(10, oo))\n",
      " |      \n",
      " |      >>> from sympy import S, EmptySet\n",
      " |      >>> S.Reals.symmetric_difference(EmptySet)\n",
      " |      Reals\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Symmetric_difference\n",
      " |  \n",
      " |  union(self, other)\n",
      " |      Returns the union of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``+`` operator:\n",
      " |      \n",
      " |      >>> from sympy import Interval, FiniteSet\n",
      " |      >>> Interval(0, 1).union(Interval(2, 3))\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(0, 1) + Interval(2, 3)\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(1, 2, True, True) + FiniteSet(2, 3)\n",
      " |      Union({3}, Interval.Lopen(1, 2))\n",
      " |      \n",
      " |      Similarly it is possible to use the ``-`` operator for set differences:\n",
      " |      \n",
      " |      >>> Interval(0, 2) - Interval(0, 1)\n",
      " |      Interval.Lopen(1, 2)\n",
      " |      >>> Interval(1, 3) - FiniteSet(2)\n",
      " |      Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from Set:\n",
      " |  \n",
      " |  boundary\n",
      " |      The boundary or frontier of a set.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A point x is on the boundary of a set S if\n",
      " |      \n",
      " |      1.  x is in the closure of S.\n",
      " |          I.e. Every neighborhood of x contains a point in S.\n",
      " |      2.  x is not in the interior of S.\n",
      " |          I.e. There does not exist an open set centered on x contained\n",
      " |          entirely within S.\n",
      " |      \n",
      " |      There are the points on the outer rim of S.  If S is open then these\n",
      " |      points need not actually be contained within S.\n",
      " |      \n",
      " |      For example, the boundary of an interval is its start and end points.\n",
      " |      This is true regardless of whether or not the interval is open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).boundary\n",
      " |      {0, 1}\n",
      " |      >>> Interval(0, 1, True, False).boundary\n",
      " |      {0, 1}\n",
      " |  \n",
      " |  closure\n",
      " |      Property method which returns the closure of a set.\n",
      " |      The closure is defined as the union of the set itself and its\n",
      " |      boundary.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S, Interval\n",
      " |      >>> S.Reals.closure\n",
      " |      Reals\n",
      " |      >>> Interval(0, 1).closure\n",
      " |      Interval(0, 1)\n",
      " |  \n",
      " |  inf\n",
      " |      The infimum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).inf\n",
      " |      0\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).inf\n",
      " |      0\n",
      " |  \n",
      " |  interior\n",
      " |      Property method which returns the interior of a set.\n",
      " |      The interior of a set S consists all points of S that do not\n",
      " |      belong to the boundary of S.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).interior\n",
      " |      Interval.open(0, 1)\n",
      " |      >>> Interval(0, 1).boundary.interior\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_EmptySet\n",
      " |  \n",
      " |  is_closed\n",
      " |      A property method to check whether a set is closed.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is closed if its complement is an open set. The closedness of a\n",
      " |      subset of the reals is determined with respect to R and its standard\n",
      " |      topology.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_closed\n",
      " |      True\n",
      " |  \n",
      " |  is_open\n",
      " |      Property method to check whether a set is open.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is open if and only if it has an empty intersection with its\n",
      " |      boundary. In particular, a subset A of the reals is open if and only\n",
      " |      if each one of its points is contained in an open interval that is a\n",
      " |      subset of A.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S\n",
      " |      >>> S.Reals.is_open\n",
      " |      True\n",
      " |      >>> S.Rationals.is_open\n",
      " |      False\n",
      " |  \n",
      " |  kind\n",
      " |      The kind of a Set\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      Any :class:`Set` will have kind :class:`SetKind` which is\n",
      " |      parametrised by the kind of the elements of the set. For example\n",
      " |      most sets are sets of numbers and will have kind\n",
      " |      ``SetKind(NumberKind)``. If elements of sets are different in kind than\n",
      " |      their kind will ``SetKind(UndefinedKind)``. See\n",
      " |      :class:`sympy.core.kind.Kind` for an explanation of the kind system.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet\n",
      " |      \n",
      " |      >>> FiniteSet(Matrix([1, 2])).kind\n",
      " |      SetKind(MatrixKind(NumberKind))\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind\n",
      " |      SetKind(NumberKind)\n",
      " |      \n",
      " |      >>> EmptySet.kind\n",
      " |      SetKind()\n",
      " |      \n",
      " |      A :class:`sympy.sets.powerset.PowerSet` is a set of sets:\n",
      " |      \n",
      " |      >>> PowerSet({1, 2, 3}).kind\n",
      " |      SetKind(SetKind(NumberKind))\n",
      " |      \n",
      " |      A :class:`ProductSet` represents the set of tuples of elements of\n",
      " |      other sets. Its kind is :class:`sympy.core.containers.TupleKind`\n",
      " |      parametrised by the kinds of the elements of those sets:\n",
      " |      \n",
      " |      >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))\n",
      " |      >>> list(p)\n",
      " |      [(1, 3), (2, 3), (1, 4), (2, 4)]\n",
      " |      >>> p.kind\n",
      " |      SetKind(TupleKind(NumberKind, NumberKind))\n",
      " |      \n",
      " |      When all elements of the set do not have same kind, the kind\n",
      " |      will be returned as ``SetKind(UndefinedKind)``:\n",
      " |      \n",
      " |      >>> FiniteSet(0, Matrix([1, 2])).kind\n",
      " |      SetKind(UndefinedKind)\n",
      " |      \n",
      " |      The kind of the elements of a set are given by the ``element_kind``\n",
      " |      attribute of ``SetKind``:\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind.element_kind\n",
      " |      NumberKind\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      NumberKind\n",
      " |      sympy.core.kind.UndefinedKind\n",
      " |      sympy.core.containers.TupleKind\n",
      " |      MatrixKind\n",
      " |      sympy.matrices.expressions.sets.MatrixSet\n",
      " |      sympy.sets.conditionset.ConditionSet\n",
      " |      Rationals\n",
      " |      Naturals\n",
      " |      Integers\n",
      " |      sympy.sets.fancysets.ImageSet\n",
      " |      sympy.sets.fancysets.Range\n",
      " |      sympy.sets.fancysets.ComplexRegion\n",
      " |      sympy.sets.powerset.PowerSet\n",
      " |      sympy.sets.sets.ProductSet\n",
      " |      sympy.sets.sets.Interval\n",
      " |      sympy.sets.sets.Union\n",
      " |      sympy.sets.sets.Intersection\n",
      " |      sympy.sets.sets.Complement\n",
      " |      sympy.sets.sets.EmptySet\n",
      " |      sympy.sets.sets.UniversalSet\n",
      " |      sympy.sets.sets.FiniteSet\n",
      " |      sympy.sets.sets.SymmetricDifference\n",
      " |      sympy.sets.sets.DisjointUnion\n",
      " |  \n",
      " |  measure\n",
      " |      The (Lebesgue) measure of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).measure\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).measure\n",
      " |      2\n",
      " |  \n",
      " |  sup\n",
      " |      The supremum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).sup\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).sup\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Set:\n",
      " |  \n",
      " |  is_Complement = None\n",
      " |  \n",
      " |  is_ComplexRegion = False\n",
      " |  \n",
      " |  is_FiniteSet = False\n",
      " |  \n",
      " |  is_Intersection = None\n",
      " |  \n",
      " |  is_ProductSet = False\n",
      " |  \n",
      " |  is_Union = False\n",
      " |  \n",
      " |  is_UniversalSet = None\n",
      " |  \n",
      " |  is_interval = False\n",
      " |  \n",
      " |  is_iterable = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'tuple[Basic, ...]', '_mhash': 'int | None...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Interval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "id": "1521f02e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - n^{2} + 3 n + 4$"
      ],
      "text/plain": [
       "-n**2 + 3*n + 4"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=quadratic_function(S(-1),S(3),S(4))\n",
    "q.to_expr(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "id": "5e9b97d1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{25}{4} - \\left(n - \\frac{3}{2}\\right)^{2}$"
      ],
      "text/plain": [
       "25/4 - (n - 3/2)**2"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "S(q.to_symmetry_expr(n))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "id": "6ecaf454",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(4, \\frac{25}{4}\\right]$"
      ],
      "text/plain": [
       "Interval.Lopen(4, 25/4)"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_range(q.to_expr(n),n,Interval.open(0,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "id": "737a0d25",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 99 x^{2} + 16 y^{2}$"
      ],
      "text/plain": [
       "99*x**2 + 16*y**2"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s=99*x**2+16*y**2\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "id": "7fda2a26",
   "metadata": {},
   "outputs": [],
   "source": [
    "expr=s.subs(y,20/x-x/4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "id": "43605951",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 100 x^{2} - 160 + \\frac{6400}{x^{2}}$"
      ],
      "text/plain": [
       "100*x**2 - 160 + 6400/x**2"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expand(expr))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "id": "90b358bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2 x^{2} - 4 x y + 3 y^{2}$"
      ],
      "text/plain": [
       "2*x**2 - 4*x*y + 3*y**2"
      ]
     },
     "execution_count": 231,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=2*x**2+3*y**2-4*x*y\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "id": "a9a7d26f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{3 \\sin^{2}{\\left(t \\right)}}{\\cos^{2}{\\left(t \\right)}} - \\frac{4 \\sin{\\left(t \\right)}}{\\cos^{2}{\\left(t \\right)}} + \\frac{2}{\\cos^{2}{\\left(t \\right)}}$"
      ],
      "text/plain": [
       "3*sin(t)**2/cos(t)**2 - 4*sin(t)/cos(t)**2 + 2/cos(t)**2"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr1=expr.subs([(x,1/cos(t)),(y,sin(t)/cos(t))])\n",
    "expr1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "id": "6d186677",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -3 + \\frac{9}{2 \\left(\\sin{\\left(t \\right)} + 1\\right)} - \\frac{1}{2 \\left(\\sin{\\left(t \\right)} - 1\\right)}$"
      ],
      "text/plain": [
       "-3 + 9/(2*(sin(t) + 1)) - 1/(2*(sin(t) - 1))"
      ]
     },
     "execution_count": 237,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr2=expr1.subs(cos(t)**2,1-sin(t)**2)\n",
    "apart(expr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "id": "9cb9d906",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 3 \\left(- \\frac{m}{2} + \\frac{n}{2}\\right)^{2} - 4 \\left(- \\frac{m}{2} + \\frac{n}{2}\\right) \\left(\\frac{m}{2} + \\frac{n}{2}\\right) + 2 \\left(\\frac{m}{2} + \\frac{n}{2}\\right)^{2}$"
      ],
      "text/plain": [
       "3*(-m/2 + n/2)**2 - 4*(-m/2 + n/2)*(m/2 + n/2) + 2*(m/2 + n/2)**2"
      ]
     },
     "execution_count": 239,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr4=expr.subs([(x,(m+n)/2),(y,(n-m)/2)])\n",
    "expr4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "id": "c3da5ef6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{9 m^{2}}{4} - \\frac{m n}{2} + \\frac{n^{2}}{4}$"
      ],
      "text/plain": [
       "9*m**2/4 - m*n/2 + n**2/4"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(expr4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "id": "ebf5d44e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} 1 - 2 x & \\text{for}\\: x < 0 \\\\- x^{2} + 2 x + 1 & \\text{otherwise} \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise((1 - 2*x, x < 0), (-x**2 + 2*x + 1, True))"
      ]
     },
     "execution_count": 242,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=Piecewise((-2*x+1,x<0),(-x**2+2*x+1,True))\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "id": "6b3f89c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "%aimport function_calculator_package"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "id": "de962452",
   "metadata": {},
   "outputs": [],
   "source": [
    "from function_calculator_package.extreme_points import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 246,
   "id": "51608ecf",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function function_monotonyset in module function_calculator_package.extreme_points:\n",
      "\n",
      "function_monotonyset(f, x, interval=Reals, dir='+-')\n",
      "    This function return the function f of x 's\n",
      "    monotony sets.\n",
      "    if f in the monotony set is increase\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(function_monotonyset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "id": "833e1b1c",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Invalid comparison of non-real zoo",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3921/2815521847.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunction_monotonyset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/Documents/packaging_tutorial/src/function_calculator_package/extreme_points.py\u001b[0m in \u001b[0;36mfunction_monotonyset\u001b[0;34m(f, x, interval, dir)\u001b[0m\n\u001b[1;32m     24\u001b[0m     \u001b[0;31m# we should first check the interval's edge.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m     \u001b[0;32mif\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minterval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mleft_open\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 26\u001b[0;31m         \u001b[0minterval_inf_value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlimit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0minterval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"+\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     27\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     28\u001b[0m         \u001b[0minterval_inf_value\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0minterval\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/limits.py\u001b[0m in \u001b[0;36mlimit\u001b[0;34m(e, z, z0, dir)\u001b[0m\n\u001b[1;32m     62\u001b[0m     \"\"\"\n\u001b[1;32m     63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mLimit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdoit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdeep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/limits.py\u001b[0m in \u001b[0;36mdoit\u001b[0;34m(self, **hints)\u001b[0m\n\u001b[1;32m    307\u001b[0m             \u001b[0mnewe\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    308\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 309\u001b[0;31m             \u001b[0mcoeff\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnewe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mleadterm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    310\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mValueError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPoleError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    311\u001b[0m             \u001b[0;31m# The NotImplementedError catching is for custom functions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/expr.py\u001b[0m in \u001b[0;36mleadterm\u001b[0;34m(self, x, logx, cdir)\u001b[0m\n\u001b[1;32m   3505\u001b[0m         \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0msymbol\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mDummy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3506\u001b[0m         \u001b[0;32mfrom\u001b[0m \u001b[0msympy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melementary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexponential\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mlog\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3507\u001b[0;31m         \u001b[0ml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlogx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3508\u001b[0m         \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDummy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'logx'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3509\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhas\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/cache.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m                 \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'unhashable type:'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/expr.py\u001b[0m in \u001b[0;36mas_leading_term\u001b[0;34m(self, logx, cdir, *symbols)\u001b[0m\n\u001b[1;32m   3468\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfree_symbols\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3469\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3470\u001b[0;31m         \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_eval_as_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlogx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3471\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3472\u001b[0m             \u001b[0;32mfrom\u001b[0m \u001b[0msympy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimplify\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpowsimp\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpowsimp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/functions/elementary/piecewise.py\u001b[0m in \u001b[0;36m_eval_as_leading_term\u001b[0;34m(self, x, logx, cdir)\u001b[0m\n\u001b[1;32m    314\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_eval_as_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    315\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 316\u001b[0;31m             \u001b[0;32mif\u001b[0m \u001b[0mc\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mTrue\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    317\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    318\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/basic.py\u001b[0m in \u001b[0;36msubs\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    995\u001b[0m             \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    996\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msequence\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 997\u001b[0;31m                 \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_subs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    998\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBasic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    999\u001b[0m                     \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/cache.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m                 \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'unhashable type:'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/basic.py\u001b[0m in \u001b[0;36m_subs\u001b[0;34m(self, old, new, **hints)\u001b[0m\n\u001b[1;32m   1109\u001b[0m         \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_eval_subs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1110\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mrv\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1111\u001b[0;31m             \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfallback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1112\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mrv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1113\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/basic.py\u001b[0m in \u001b[0;36mfallback\u001b[0;34m(self, old, new)\u001b[0m\n\u001b[1;32m   1086\u001b[0m                     \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1087\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mhit\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1088\u001b[0;31m                 \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1089\u001b[0m                 \u001b[0mhack2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhints\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'hack2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1090\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mhack2\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_Mul\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mrv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_Mul\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# 2-arg hack\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/relational.py\u001b[0m in \u001b[0;36m__new__\u001b[0;34m(cls, lhs, rhs, **options)\u001b[0m\n\u001b[1;32m    832\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mme\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlhs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrhs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    833\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mme\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_extended_real\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 834\u001b[0;31m                     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid comparison of non-real %s\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mme\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    835\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mme\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNaN\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    836\u001b[0m                     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid NaN comparison\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Invalid comparison of non-real zoo"
     ]
    }
   ],
   "source": [
    "function_monotonyset(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "id": "2cf3453b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\infty$"
      ],
      "text/plain": [
       "oo"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "limit(1-2*x,x,Reals.inf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "id": "20038b8d",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Invalid comparison of non-real zoo",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3921/140726674.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlimit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mReals\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0minf\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"+\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/limits.py\u001b[0m in \u001b[0;36mlimit\u001b[0;34m(e, z, z0, dir)\u001b[0m\n\u001b[1;32m     62\u001b[0m     \"\"\"\n\u001b[1;32m     63\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 64\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mLimit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdoit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdeep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     65\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/series/limits.py\u001b[0m in \u001b[0;36mdoit\u001b[0;34m(self, **hints)\u001b[0m\n\u001b[1;32m    307\u001b[0m             \u001b[0mnewe\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mz\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mz0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    308\u001b[0m         \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 309\u001b[0;31m             \u001b[0mcoeff\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mex\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnewe\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mleadterm\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    310\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mValueError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mPoleError\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    311\u001b[0m             \u001b[0;31m# The NotImplementedError catching is for custom functions\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/expr.py\u001b[0m in \u001b[0;36mleadterm\u001b[0;34m(self, x, logx, cdir)\u001b[0m\n\u001b[1;32m   3505\u001b[0m         \u001b[0;32mfrom\u001b[0m \u001b[0;34m.\u001b[0m\u001b[0msymbol\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mDummy\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3506\u001b[0m         \u001b[0;32mfrom\u001b[0m \u001b[0msympy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunctions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0melementary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexponential\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mlog\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3507\u001b[0;31m         \u001b[0ml\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlogx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3508\u001b[0m         \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDummy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'logx'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3509\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0ml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mhas\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/cache.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m                 \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'unhashable type:'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/expr.py\u001b[0m in \u001b[0;36mas_leading_term\u001b[0;34m(self, logx, cdir, *symbols)\u001b[0m\n\u001b[1;32m   3468\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfree_symbols\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3469\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 3470\u001b[0;31m         \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_eval_as_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlogx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcdir\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   3471\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mobj\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   3472\u001b[0m             \u001b[0;32mfrom\u001b[0m \u001b[0msympy\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msimplify\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpowsimp\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mpowsimp\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/functions/elementary/piecewise.py\u001b[0m in \u001b[0;36m_eval_as_leading_term\u001b[0;34m(self, x, logx, cdir)\u001b[0m\n\u001b[1;32m    314\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_eval_as_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlogx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcdir\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    315\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 316\u001b[0;31m             \u001b[0;32mif\u001b[0m \u001b[0mc\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mTrue\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    317\u001b[0m                 \u001b[0;32mreturn\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_leading_term\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    318\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/basic.py\u001b[0m in \u001b[0;36msubs\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    995\u001b[0m             \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    996\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msequence\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 997\u001b[0;31m                 \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mrv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_subs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    998\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrv\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBasic\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    999\u001b[0m                     \u001b[0;32mbreak\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/cache.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m     68\u001b[0m         \u001b[0;32mdef\u001b[0m \u001b[0mwrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m                 \u001b[0mretval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'unhashable type:'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/basic.py\u001b[0m in \u001b[0;36m_subs\u001b[0;34m(self, old, new, **hints)\u001b[0m\n\u001b[1;32m   1109\u001b[0m         \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_eval_subs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1110\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mrv\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1111\u001b[0;31m             \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfallback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1112\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mrv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1113\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/basic.py\u001b[0m in \u001b[0;36mfallback\u001b[0;34m(self, old, new)\u001b[0m\n\u001b[1;32m   1086\u001b[0m                     \u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0marg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1087\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mhit\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1088\u001b[0;31m                 \u001b[0mrv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1089\u001b[0m                 \u001b[0mhack2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhints\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'hack2'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1090\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mhack2\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_Mul\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mrv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_Mul\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# 2-arg hack\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.9/site-packages/sympy/core/relational.py\u001b[0m in \u001b[0;36m__new__\u001b[0;34m(cls, lhs, rhs, **options)\u001b[0m\n\u001b[1;32m    832\u001b[0m             \u001b[0;32mfor\u001b[0m \u001b[0mme\u001b[0m \u001b[0;32min\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mlhs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrhs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    833\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mme\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mis_extended_real\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 834\u001b[0;31m                     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid comparison of non-real %s\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mme\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    835\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mme\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mS\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNaN\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    836\u001b[0m                     \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid NaN comparison\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Invalid comparison of non-real zoo"
     ]
    }
   ],
   "source": [
    "limit(expr,x,Reals.inf,\"+\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "id": "b4a0cfcb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\begin{cases} -2 & \\text{for}\\: x < 0 \\\\2 - 2 x & \\text{otherwise} \\end{cases}$"
      ],
      "text/plain": [
       "Piecewise((-2, x < 0), (2 - 2*x, True))"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "diff(expr,x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 256,
   "id": "2f82121c",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd57cff0c70>"
      ]
     },
     "execution_count": 256,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,-3,8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "d59eb76c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{- x^{2} + 4 x}$"
      ],
      "text/plain": [
       "sqrt(-x**2 + 4*x)"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=sqrt(-x**2+4*x)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "id": "175a3763",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'+': [Interval.open(0, 2)], '-': [Interval.open(2, 4)]}"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_monotonyset(expr,x,continuous_domain(expr,x,Reals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "id": "95507610",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, - \\frac{1}{5}\\right] \\cup \\left(0, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval(-oo, -1/5), Interval.open(0, oo))"
      ]
     },
     "execution_count": 260,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(-(k+1)/(2*k)<=2,k,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "id": "fe165ca9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\sqrt{x^{2} - 2 x - 3}$"
      ],
      "text/plain": [
       "sqrt(x**2 - 2*x - 3)"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=sqrt(x**2-2*x-3)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "id": "c659be46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[3, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval(3, oo)"
      ]
     },
     "execution_count": 268,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "continuous_domain(expr,x,Reals).args[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "id": "da3008ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x \\left|{x - 2}\\right|$"
      ],
      "text/plain": [
       "x*Abs(x - 2)"
      ]
     },
     "execution_count": 269,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=x*abs(x-2)\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "id": "dfc435c2",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "ename": "NotImplementedError",
     "evalue": "We haven't handle the type of diff(f)'s solveset type:\n<class 'sympy.sets.sets.Union'>\nplease wait.",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[0;32m/tmp/ipykernel_3921/708581727.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfunction_monotonyset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mcontinuous_domain\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mReals\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/Documents/packaging_tutorial/src/function_calculator_package/extreme_points.py\u001b[0m in \u001b[0;36mfunction_monotonyset\u001b[0;34m(f, x, interval, dir)\u001b[0m\n\u001b[1;32m     53\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'\\n'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"We haven't handle the type of diff(f)'s solveset type:\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mset_type\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"please wait.\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0;31m# if the set is ImageSet or it's Union,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m     \u001b[0;31m# it can also work, but I don't how to\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNotImplementedError\u001b[0m: We haven't handle the type of diff(f)'s solveset type:\n<class 'sympy.sets.sets.Union'>\nplease wait."
     ]
    }
   ],
   "source": [
    "function_monotonyset(expr,x,continuous_domain(expr,x,Reals))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 271,
   "id": "63e1b0c6",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd58ffc27c0>"
      ]
     },
     "execution_count": 271,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,-2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 272,
   "id": "d8b2676d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle x^{2} + 1 - \\frac{2}{x}$"
      ],
      "text/plain": [
       "x**2 + 1 - 2/x"
      ]
     },
     "execution_count": 272,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "expr=x**2-2/x+1\n",
    "expr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "id": "1ebd387b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'+': Interval.open(0, oo), '-': []}"
      ]
     },
     "execution_count": 274,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function_monotonyset(expr,x,Interval.open(0,oo))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "id": "4e3e2d75",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "<sympy.plotting.plot.Plot at 0x7fd58fe999d0>"
      ]
     },
     "execution_count": 275,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plot(expr,(x,1/2,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 277,
   "id": "e4bc2d85",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.abc import a,b,c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d008951",
   "metadata": {},
   "outputs": [],
   "source": [
    "q=quadratic_function(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 284,
   "id": "fdab384e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{b}{2 a} = 1$"
      ],
      "text/plain": [
       "Eq(-b/(2*a), 1)"
      ]
     },
     "execution_count": 284,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq1=Eq(q.symmetry,1)\n",
    "eq1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 285,
   "id": "139cbaa2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle c - \\frac{b^{2}}{4 a} = -4$"
      ],
      "text/plain": [
       "Eq(c - b**2/(4*a), -4)"
      ]
     },
     "execution_count": 285,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq2=Eq(q.extreme_value(),-4)\n",
    "eq2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "id": "ea3f04e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 9 a + 3 b + c = 0$"
      ],
      "text/plain": [
       "Eq(9*a + 3*b + c, 0)"
      ]
     },
     "execution_count": 286,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq3=Eq(q.to_expr(x).subs(x,3),0)\n",
    "eq3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "id": "a8816aa7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a - b + c = 0$"
      ],
      "text/plain": [
       "Eq(a - b + c, 0)"
      ]
     },
     "execution_count": 289,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq3=Eq(q.to_expr(x).subs(x,-1),0)\n",
    "eq3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "id": "11b70521",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( 0, \\  0, \\  0\\right), \\left( 1, \\  -2, \\  -3\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(0, 0, 0), (1, -2, -3)}"
      ]
     },
     "execution_count": 287,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nonlinsolve([eq1,eq2,eq3],[a,b,c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 292,
   "id": "9e6c8a6f",
   "metadata": {},
   "outputs": [],
   "source": [
    "answer=solve_univariate_inequality(abs(3*x**2+2*x+1)>2*abs(x**2-2*x+3),x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 294,
   "id": "f652c704",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty < x \\wedge x < - \\sqrt{14} - 3\\right) \\vee \\left(x < \\infty \\wedge -3 + \\sqrt{14} < x\\right)$"
      ],
      "text/plain": [
       "((x < oo) & (-3 + sqrt(14) < x)) | ((-oo < x) & (x < -sqrt(14) - 3))"
      ]
     },
     "execution_count": 294,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "id": "b2b79f93",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sympy.solvers.inequalities import reduce_rational_inequalities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "id": "51403d3c",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function reduce_rational_inequalities in module sympy.solvers.inequalities:\n",
      "\n",
      "reduce_rational_inequalities(exprs, gen, relational=True)\n",
      "    Reduce a system of rational inequalities with rational coefficients.\n",
      "    \n",
      "    Examples\n",
      "    ========\n",
      "    \n",
      "    >>> from sympy import Symbol\n",
      "    >>> from sympy.solvers.inequalities import reduce_rational_inequalities\n",
      "    \n",
      "    >>> x = Symbol('x', real=True)\n",
      "    \n",
      "    >>> reduce_rational_inequalities([[x**2 <= 0]], x)\n",
      "    Eq(x, 0)\n",
      "    \n",
      "    >>> reduce_rational_inequalities([[x + 2 > 0]], x)\n",
      "    -2 < x\n",
      "    >>> reduce_rational_inequalities([[(x + 2, \">\")]], x)\n",
      "    -2 < x\n",
      "    >>> reduce_rational_inequalities([[x + 2]], x)\n",
      "    Eq(x, -2)\n",
      "    \n",
      "    This function find the non-infinite solution set so if the unknown symbol\n",
      "    is declared as extended real rather than real then the result may include\n",
      "    finiteness conditions:\n",
      "    \n",
      "    >>> y = Symbol('y', extended_real=True)\n",
      "    >>> reduce_rational_inequalities([[y + 2 > 0]], y)\n",
      "    (-2 < y) & (y < oo)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(reduce_rational_inequalities)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "id": "fa4cc55a",
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y=symbols(\"x,y\",real=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "id": "f75f6968",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class Poly in module sympy.polys.polytools:\n",
      "\n",
      "class Poly(sympy.core.basic.Basic)\n",
      " |  Poly(rep, *gens, **args)\n",
      " |  \n",
      " |  Generic class for representing and operating on polynomial expressions.\n",
      " |  \n",
      " |  See :ref:`polys-docs` for general documentation.\n",
      " |  \n",
      " |  Poly is a subclass of Basic rather than Expr but instances can be\n",
      " |  converted to Expr with the :py:meth:`~.Poly.as_expr` method.\n",
      " |  \n",
      " |  .. deprecated:: 1.6\n",
      " |  \n",
      " |     Combining Poly with non-Poly objects in binary operations is\n",
      " |     deprecated. Explicitly convert both objects to either Poly or Expr\n",
      " |     first. See :ref:`deprecated-poly-nonpoly-binary-operations`.\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Poly\n",
      " |  >>> from sympy.abc import x, y\n",
      " |  \n",
      " |  Create a univariate polynomial:\n",
      " |  \n",
      " |  >>> Poly(x*(x**2 + x - 1)**2)\n",
      " |  Poly(x**5 + 2*x**4 - x**3 - 2*x**2 + x, x, domain='ZZ')\n",
      " |  \n",
      " |  Create a univariate polynomial with specific domain:\n",
      " |  \n",
      " |  >>> from sympy import sqrt\n",
      " |  >>> Poly(x**2 + 2*x + sqrt(3), domain='R')\n",
      " |  Poly(1.0*x**2 + 2.0*x + 1.73205080756888, x, domain='RR')\n",
      " |  \n",
      " |  Create a multivariate polynomial:\n",
      " |  \n",
      " |  >>> Poly(y*x**2 + x*y + 1)\n",
      " |  Poly(x**2*y + x*y + 1, x, y, domain='ZZ')\n",
      " |  \n",
      " |  Create a univariate polynomial, where y is a constant:\n",
      " |  \n",
      " |  >>> Poly(y*x**2 + x*y + 1,x)\n",
      " |  Poly(y*x**2 + y*x + 1, x, domain='ZZ[y]')\n",
      " |  \n",
      " |  You can evaluate the above polynomial as a function of y:\n",
      " |  \n",
      " |  >>> Poly(y*x**2 + x*y + 1,x).eval(2)\n",
      " |  6*y + 1\n",
      " |  \n",
      " |  See Also\n",
      " |  ========\n",
      " |  \n",
      " |  sympy.core.expr.Expr\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Poly\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  EC(f, order=None)\n",
      " |      Returns the last non-zero coefficient of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 + 2*x**2 + 3*x, x).EC()\n",
      " |      3\n",
      " |  \n",
      " |  EM(f, order=None)\n",
      " |      Returns the last non-zero monomial of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).EM()\n",
      " |      x**0*y**1\n",
      " |  \n",
      " |  ET(f, order=None)\n",
      " |      Returns the last non-zero term of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).ET()\n",
      " |      (x**0*y**1, 3)\n",
      " |  \n",
      " |  LC(f, order=None)\n",
      " |      Returns the leading coefficient of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(4*x**3 + 2*x**2 + 3*x, x).LC()\n",
      " |      4\n",
      " |  \n",
      " |  LM(f, order=None)\n",
      " |      Returns the leading monomial of ``f``.\n",
      " |      \n",
      " |      The Leading monomial signifies the monomial having\n",
      " |      the highest power of the principal generator in the\n",
      " |      expression f.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LM()\n",
      " |      x**2*y**0\n",
      " |  \n",
      " |  LT(f, order=None)\n",
      " |      Returns the leading term of ``f``.\n",
      " |      \n",
      " |      The Leading term signifies the term having\n",
      " |      the highest power of the principal generator in the\n",
      " |      expression f along with its coefficient.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(4*x**2 + 2*x*y**2 + x*y + 3*y, x, y).LT()\n",
      " |      (x**2*y**0, 4)\n",
      " |  \n",
      " |  TC(f)\n",
      " |      Returns the trailing coefficient of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 + 2*x**2 + 3*x, x).TC()\n",
      " |      0\n",
      " |  \n",
      " |  __abs__(f)\n",
      " |  \n",
      " |  __add__(f, g)\n",
      " |  \n",
      " |  __bool__(f)\n",
      " |  \n",
      " |  __call__(f, *values)\n",
      " |      Evaluate ``f`` at the give values.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z)\n",
      " |      \n",
      " |      >>> f(2)\n",
      " |      Poly(5*y + 2*z + 6, y, z, domain='ZZ')\n",
      " |      >>> f(2, 5)\n",
      " |      Poly(2*z + 31, z, domain='ZZ')\n",
      " |      >>> f(2, 5, 7)\n",
      " |      45\n",
      " |  \n",
      " |  __divmod__(f, g)\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __floordiv__(f, g)\n",
      " |  \n",
      " |  __hash__(self)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __mod__(f, g)\n",
      " |  \n",
      " |  __mul__(f, g)\n",
      " |  \n",
      " |  __ne__(f, g)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __neg__(f)\n",
      " |  \n",
      " |  __pow__(f, n)\n",
      " |  \n",
      " |  __radd__(f, g)\n",
      " |  \n",
      " |  __rdivmod__(f, g)\n",
      " |  \n",
      " |  __rfloordiv__(f, g)\n",
      " |  \n",
      " |  __rmod__(f, g)\n",
      " |  \n",
      " |  __rmul__(f, g)\n",
      " |  \n",
      " |  __rsub__(f, g)\n",
      " |  \n",
      " |  __rtruediv__(f, g)\n",
      " |  \n",
      " |  __sub__(f, g)\n",
      " |  \n",
      " |  __truediv__(f, g)\n",
      " |  \n",
      " |  abs(f)\n",
      " |      Make all coefficients in ``f`` positive.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).abs()\n",
      " |      Poly(x**2 + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  add(f, g)\n",
      " |      Add two polynomials ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).add(Poly(x - 2, x))\n",
      " |      Poly(x**2 + x - 1, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x) + Poly(x - 2, x)\n",
      " |      Poly(x**2 + x - 1, x, domain='ZZ')\n",
      " |  \n",
      " |  add_ground(f, coeff)\n",
      " |      Add an element of the ground domain to ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x + 1).add_ground(2)\n",
      " |      Poly(x + 3, x, domain='ZZ')\n",
      " |  \n",
      " |  all_coeffs(f)\n",
      " |      Returns all coefficients from a univariate polynomial ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 + 2*x - 1, x).all_coeffs()\n",
      " |      [1, 0, 2, -1]\n",
      " |  \n",
      " |  all_monoms(f)\n",
      " |      Returns all monomials from a univariate polynomial ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 + 2*x - 1, x).all_monoms()\n",
      " |      [(3,), (2,), (1,), (0,)]\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      all_terms\n",
      " |  \n",
      " |  all_roots(f, multiple=True, radicals=True)\n",
      " |      Return a list of real and complex roots with multiplicities.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).all_roots()\n",
      " |      [-1/2, 2, 2]\n",
      " |      >>> Poly(x**3 + x + 1).all_roots()\n",
      " |      [CRootOf(x**3 + x + 1, 0),\n",
      " |       CRootOf(x**3 + x + 1, 1),\n",
      " |       CRootOf(x**3 + x + 1, 2)]\n",
      " |  \n",
      " |  all_terms(f)\n",
      " |      Returns all terms from a univariate polynomial ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 + 2*x - 1, x).all_terms()\n",
      " |      [((3,), 1), ((2,), 0), ((1,), 2), ((0,), -1)]\n",
      " |  \n",
      " |  as_dict(f, native=False, zero=False)\n",
      " |      Switch to a ``dict`` representation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x*y**2 - y, x, y).as_dict()\n",
      " |      {(0, 1): -1, (1, 2): 2, (2, 0): 1}\n",
      " |  \n",
      " |  as_expr(f, *gens)\n",
      " |      Convert a Poly instance to an Expr instance.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = Poly(x**2 + 2*x*y**2 - y, x, y)\n",
      " |      \n",
      " |      >>> f.as_expr()\n",
      " |      x**2 + 2*x*y**2 - y\n",
      " |      >>> f.as_expr({x: 5})\n",
      " |      10*y**2 - y + 25\n",
      " |      >>> f.as_expr(5, 6)\n",
      " |      379\n",
      " |  \n",
      " |  as_list(f, native=False)\n",
      " |      Switch to a ``list`` representation.\n",
      " |  \n",
      " |  as_poly(self, *gens, **args)\n",
      " |      Converts ``self`` to a polynomial or returns ``None``.\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly())\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + x*y).as_poly(x, y))\n",
      " |      Poly(x**2 + x*y, x, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> print((x**2 + sin(y)).as_poly(x, y))\n",
      " |      None\n",
      " |  \n",
      " |  cancel(f, g, include=False)\n",
      " |      Cancel common factors in a rational function ``f/g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x))\n",
      " |      (1, Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ'))\n",
      " |      \n",
      " |      >>> Poly(2*x**2 - 2, x).cancel(Poly(x**2 - 2*x + 1, x), include=True)\n",
      " |      (Poly(2*x + 2, x, domain='ZZ'), Poly(x - 1, x, domain='ZZ'))\n",
      " |  \n",
      " |  clear_denoms(self, convert=False)\n",
      " |      Clear denominators, but keep the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, S, QQ\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = Poly(x/2 + S(1)/3, x, domain=QQ)\n",
      " |      \n",
      " |      >>> f.clear_denoms()\n",
      " |      (6, Poly(3*x + 2, x, domain='QQ'))\n",
      " |      >>> f.clear_denoms(convert=True)\n",
      " |      (6, Poly(3*x + 2, x, domain='ZZ'))\n",
      " |  \n",
      " |  coeff(f, x, n=1, right=False)\n",
      " |  \n",
      " |  coeff_monomial(f, monom)\n",
      " |      Returns the coefficient of ``monom`` in ``f`` if there, else None.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, exp\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> p = Poly(24*x*y*exp(8) + 23*x, x, y)\n",
      " |      \n",
      " |      >>> p.coeff_monomial(x)\n",
      " |      23\n",
      " |      >>> p.coeff_monomial(y)\n",
      " |      0\n",
      " |      >>> p.coeff_monomial(x*y)\n",
      " |      24*exp(8)\n",
      " |      \n",
      " |      Note that ``Expr.coeff()`` behaves differently, collecting terms\n",
      " |      if possible; the Poly must be converted to an Expr to use that\n",
      " |      method, however:\n",
      " |      \n",
      " |      >>> p.as_expr().coeff(x)\n",
      " |      24*y*exp(8) + 23\n",
      " |      >>> p.as_expr().coeff(y)\n",
      " |      24*x*exp(8)\n",
      " |      >>> p.as_expr().coeff(x*y)\n",
      " |      24*exp(8)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      nth: more efficient query using exponents of the monomial's generators\n",
      " |  \n",
      " |  coeffs(f, order=None)\n",
      " |      Returns all non-zero coefficients from ``f`` in lex order.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 + 2*x + 3, x).coeffs()\n",
      " |      [1, 2, 3]\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      all_coeffs\n",
      " |      coeff_monomial\n",
      " |      nth\n",
      " |  \n",
      " |  cofactors(f, g)\n",
      " |      Returns the GCD of ``f`` and ``g`` and their cofactors.\n",
      " |      \n",
      " |      Returns polynomials ``(h, cff, cfg)`` such that ``h = gcd(f, g)``, and\n",
      " |      ``cff = quo(f, h)`` and ``cfg = quo(g, h)`` are, so called, cofactors\n",
      " |      of ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).cofactors(Poly(x**2 - 3*x + 2, x))\n",
      " |      (Poly(x - 1, x, domain='ZZ'),\n",
      " |       Poly(x + 1, x, domain='ZZ'),\n",
      " |       Poly(x - 2, x, domain='ZZ'))\n",
      " |  \n",
      " |  compose(f, g)\n",
      " |      Computes the functional composition of ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + x, x).compose(Poly(x - 1, x))\n",
      " |      Poly(x**2 - x, x, domain='ZZ')\n",
      " |  \n",
      " |  content(f)\n",
      " |      Returns the GCD of polynomial coefficients.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(6*x**2 + 8*x + 12, x).content()\n",
      " |      2\n",
      " |  \n",
      " |  count_roots(f, inf=None, sup=None)\n",
      " |      Return the number of roots of ``f`` in ``[inf, sup]`` interval.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**4 - 4, x).count_roots(-3, 3)\n",
      " |      2\n",
      " |      >>> Poly(x**4 - 4, x).count_roots(0, 1 + 3*I)\n",
      " |      1\n",
      " |  \n",
      " |  decompose(f)\n",
      " |      Computes a functional decomposition of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**4 + 2*x**3 - x - 1, x, domain='ZZ').decompose()\n",
      " |      [Poly(x**2 - x - 1, x, domain='ZZ'), Poly(x**2 + x, x, domain='ZZ')]\n",
      " |  \n",
      " |  deflate(f)\n",
      " |      Reduce degree of ``f`` by mapping ``x_i**m`` to ``y_i``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**6*y**2 + x**3 + 1, x, y).deflate()\n",
      " |      ((3, 2), Poly(x**2*y + x + 1, x, y, domain='ZZ'))\n",
      " |  \n",
      " |  degree(f, gen=0)\n",
      " |      Returns degree of ``f`` in ``x_j``.\n",
      " |      \n",
      " |      The degree of 0 is negative infinity.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + y*x + 1, x, y).degree()\n",
      " |      2\n",
      " |      >>> Poly(x**2 + y*x + y, x, y).degree(y)\n",
      " |      1\n",
      " |      >>> Poly(0, x).degree()\n",
      " |      -oo\n",
      " |  \n",
      " |  degree_list(f)\n",
      " |      Returns a list of degrees of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + y*x + 1, x, y).degree_list()\n",
      " |      (2, 1)\n",
      " |  \n",
      " |  diff(f, *specs, **kwargs)\n",
      " |      Computes partial derivative of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x + 1, x).diff()\n",
      " |      Poly(2*x + 2, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x*y**2 + x, x, y).diff((0, 0), (1, 1))\n",
      " |      Poly(2*x*y, x, y, domain='ZZ')\n",
      " |  \n",
      " |  discriminant(f)\n",
      " |      Computes the discriminant of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x + 3, x).discriminant()\n",
      " |      -8\n",
      " |  \n",
      " |  dispersion(f, g=None)\n",
      " |      Compute the *dispersion* of polynomials.\n",
      " |      \n",
      " |      For two polynomials `f(x)` and `g(x)` with `\\deg f > 0`\n",
      " |      and `\\deg g > 0` the dispersion `\\operatorname{dis}(f, g)` is defined as:\n",
      " |      \n",
      " |      .. math::\n",
      " |          \\operatorname{dis}(f, g)\n",
      " |          & := \\max\\{ J(f,g) \\cup \\{0\\} \\} \\\\\n",
      " |          &  = \\max\\{ \\{a \\in \\mathbb{N} | \\gcd(f(x), g(x+a)) \\neq 1\\} \\cup \\{0\\} \\}\n",
      " |      \n",
      " |      and for a single polynomial `\\operatorname{dis}(f) := \\operatorname{dis}(f, f)`.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import poly\n",
      " |      >>> from sympy.polys.dispersion import dispersion, dispersionset\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      Dispersion set and dispersion of a simple polynomial:\n",
      " |      \n",
      " |      >>> fp = poly((x - 3)*(x + 3), x)\n",
      " |      >>> sorted(dispersionset(fp))\n",
      " |      [0, 6]\n",
      " |      >>> dispersion(fp)\n",
      " |      6\n",
      " |      \n",
      " |      Note that the definition of the dispersion is not symmetric:\n",
      " |      \n",
      " |      >>> fp = poly(x**4 - 3*x**2 + 1, x)\n",
      " |      >>> gp = fp.shift(-3)\n",
      " |      >>> sorted(dispersionset(fp, gp))\n",
      " |      [2, 3, 4]\n",
      " |      >>> dispersion(fp, gp)\n",
      " |      4\n",
      " |      >>> sorted(dispersionset(gp, fp))\n",
      " |      []\n",
      " |      >>> dispersion(gp, fp)\n",
      " |      -oo\n",
      " |      \n",
      " |      Computing the dispersion also works over field extensions:\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>')\n",
      " |      >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>')\n",
      " |      >>> sorted(dispersionset(fp, gp))\n",
      " |      [2]\n",
      " |      >>> sorted(dispersionset(gp, fp))\n",
      " |      [1, 4]\n",
      " |      \n",
      " |      We can even perform the computations for polynomials\n",
      " |      having symbolic coefficients:\n",
      " |      \n",
      " |      >>> from sympy.abc import a\n",
      " |      >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x)\n",
      " |      >>> sorted(dispersionset(fp))\n",
      " |      [0, 1]\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      dispersionset\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      1. [ManWright94]_\n",
      " |      2. [Koepf98]_\n",
      " |      3. [Abramov71]_\n",
      " |      4. [Man93]_\n",
      " |  \n",
      " |  dispersionset(f, g=None)\n",
      " |      Compute the *dispersion set* of two polynomials.\n",
      " |      \n",
      " |      For two polynomials `f(x)` and `g(x)` with `\\deg f > 0`\n",
      " |      and `\\deg g > 0` the dispersion set `\\operatorname{J}(f, g)` is defined as:\n",
      " |      \n",
      " |      .. math::\n",
      " |          \\operatorname{J}(f, g)\n",
      " |          & := \\{a \\in \\mathbb{N}_0 | \\gcd(f(x), g(x+a)) \\neq 1\\} \\\\\n",
      " |          &  = \\{a \\in \\mathbb{N}_0 | \\deg \\gcd(f(x), g(x+a)) \\geq 1\\}\n",
      " |      \n",
      " |      For a single polynomial one defines `\\operatorname{J}(f) := \\operatorname{J}(f, f)`.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import poly\n",
      " |      >>> from sympy.polys.dispersion import dispersion, dispersionset\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      Dispersion set and dispersion of a simple polynomial:\n",
      " |      \n",
      " |      >>> fp = poly((x - 3)*(x + 3), x)\n",
      " |      >>> sorted(dispersionset(fp))\n",
      " |      [0, 6]\n",
      " |      >>> dispersion(fp)\n",
      " |      6\n",
      " |      \n",
      " |      Note that the definition of the dispersion is not symmetric:\n",
      " |      \n",
      " |      >>> fp = poly(x**4 - 3*x**2 + 1, x)\n",
      " |      >>> gp = fp.shift(-3)\n",
      " |      >>> sorted(dispersionset(fp, gp))\n",
      " |      [2, 3, 4]\n",
      " |      >>> dispersion(fp, gp)\n",
      " |      4\n",
      " |      >>> sorted(dispersionset(gp, fp))\n",
      " |      []\n",
      " |      >>> dispersion(gp, fp)\n",
      " |      -oo\n",
      " |      \n",
      " |      Computing the dispersion also works over field extensions:\n",
      " |      \n",
      " |      >>> from sympy import sqrt\n",
      " |      >>> fp = poly(x**2 + sqrt(5)*x - 1, x, domain='QQ<sqrt(5)>')\n",
      " |      >>> gp = poly(x**2 + (2 + sqrt(5))*x + sqrt(5), x, domain='QQ<sqrt(5)>')\n",
      " |      >>> sorted(dispersionset(fp, gp))\n",
      " |      [2]\n",
      " |      >>> sorted(dispersionset(gp, fp))\n",
      " |      [1, 4]\n",
      " |      \n",
      " |      We can even perform the computations for polynomials\n",
      " |      having symbolic coefficients:\n",
      " |      \n",
      " |      >>> from sympy.abc import a\n",
      " |      >>> fp = poly(4*x**4 + (4*a + 8)*x**3 + (a**2 + 6*a + 4)*x**2 + (a**2 + 2*a)*x, x)\n",
      " |      >>> sorted(dispersionset(fp))\n",
      " |      [0, 1]\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      dispersion\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      1. [ManWright94]_\n",
      " |      2. [Koepf98]_\n",
      " |      3. [Abramov71]_\n",
      " |      4. [Man93]_\n",
      " |  \n",
      " |  div(f, g, auto=True)\n",
      " |      Polynomial division with remainder of ``f`` by ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x))\n",
      " |      (Poly(1/2*x + 1, x, domain='QQ'), Poly(5, x, domain='QQ'))\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).div(Poly(2*x - 4, x), auto=False)\n",
      " |      (Poly(0, x, domain='ZZ'), Poly(x**2 + 1, x, domain='ZZ'))\n",
      " |  \n",
      " |  eject(f, *gens)\n",
      " |      Eject selected generators into the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x, y)\n",
      " |      \n",
      " |      >>> f.eject(x)\n",
      " |      Poly(x*y**3 + (x**2 + x)*y + 1, y, domain='ZZ[x]')\n",
      " |      >>> f.eject(y)\n",
      " |      Poly(y*x**2 + (y**3 + y)*x + 1, x, domain='ZZ[y]')\n",
      " |  \n",
      " |  eq(f, g, strict=False)\n",
      " |  \n",
      " |  eval(self, x, a=None, auto=True)\n",
      " |      Evaluate ``f`` at ``a`` in the given variable.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x + 3, x).eval(2)\n",
      " |      11\n",
      " |      \n",
      " |      >>> Poly(2*x*y + 3*x + y + 2, x, y).eval(x, 2)\n",
      " |      Poly(5*y + 8, y, domain='ZZ')\n",
      " |      \n",
      " |      >>> f = Poly(2*x*y + 3*x + y + 2*z, x, y, z)\n",
      " |      \n",
      " |      >>> f.eval({x: 2})\n",
      " |      Poly(5*y + 2*z + 6, y, z, domain='ZZ')\n",
      " |      >>> f.eval({x: 2, y: 5})\n",
      " |      Poly(2*z + 31, z, domain='ZZ')\n",
      " |      >>> f.eval({x: 2, y: 5, z: 7})\n",
      " |      45\n",
      " |      \n",
      " |      >>> f.eval((2, 5))\n",
      " |      Poly(2*z + 31, z, domain='ZZ')\n",
      " |      >>> f(2, 5)\n",
      " |      Poly(2*z + 31, z, domain='ZZ')\n",
      " |  \n",
      " |  exclude(f)\n",
      " |      Remove unnecessary generators from ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import a, b, c, d, x\n",
      " |      \n",
      " |      >>> Poly(a + x, a, b, c, d, x).exclude()\n",
      " |      Poly(a + x, a, x, domain='ZZ')\n",
      " |  \n",
      " |  exquo(f, g, auto=True)\n",
      " |      Computes polynomial exact quotient of ``f`` by ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).exquo(Poly(x - 1, x))\n",
      " |      Poly(x + 1, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).exquo(Poly(2*x - 4, x))\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1\n",
      " |  \n",
      " |  exquo_ground(f, coeff)\n",
      " |      Exact quotient of ``f`` by a an element of the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x + 4).exquo_ground(2)\n",
      " |      Poly(x + 2, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(2*x + 3).exquo_ground(2)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      ExactQuotientFailed: 2 does not divide 3 in ZZ\n",
      " |  \n",
      " |  factor_list(f)\n",
      " |      Returns a list of irreducible factors of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y\n",
      " |      \n",
      " |      >>> Poly(f).factor_list()\n",
      " |      (2, [(Poly(x + y, x, y, domain='ZZ'), 1),\n",
      " |           (Poly(x**2 + 1, x, y, domain='ZZ'), 2)])\n",
      " |  \n",
      " |  factor_list_include(f)\n",
      " |      Returns a list of irreducible factors of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = 2*x**5 + 2*x**4*y + 4*x**3 + 4*x**2*y + 2*x + 2*y\n",
      " |      \n",
      " |      >>> Poly(f).factor_list_include()\n",
      " |      [(Poly(2*x + 2*y, x, y, domain='ZZ'), 1),\n",
      " |       (Poly(x**2 + 1, x, y, domain='ZZ'), 2)]\n",
      " |  \n",
      " |  gcd(f, g)\n",
      " |      Returns the polynomial GCD of ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).gcd(Poly(x**2 - 3*x + 2, x))\n",
      " |      Poly(x - 1, x, domain='ZZ')\n",
      " |  \n",
      " |  gcdex(f, g, auto=True)\n",
      " |      Extended Euclidean algorithm of ``f`` and ``g``.\n",
      " |      \n",
      " |      Returns ``(s, t, h)`` such that ``h = gcd(f, g)`` and ``s*f + t*g = h``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15\n",
      " |      >>> g = x**3 + x**2 - 4*x - 4\n",
      " |      \n",
      " |      >>> Poly(f).gcdex(Poly(g))\n",
      " |      (Poly(-1/5*x + 3/5, x, domain='QQ'),\n",
      " |       Poly(1/5*x**2 - 6/5*x + 2, x, domain='QQ'),\n",
      " |       Poly(x + 1, x, domain='QQ'))\n",
      " |  \n",
      " |  get_domain(f)\n",
      " |      Get the ground domain of ``f``.\n",
      " |  \n",
      " |  get_modulus(f)\n",
      " |      Get the modulus of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, modulus=2).get_modulus()\n",
      " |      2\n",
      " |  \n",
      " |  gff_list(f)\n",
      " |      Computes greatest factorial factorization of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = x**5 + 2*x**4 - x**3 - 2*x**2\n",
      " |      \n",
      " |      >>> Poly(f).gff_list()\n",
      " |      [(Poly(x, x, domain='ZZ'), 1), (Poly(x + 2, x, domain='ZZ'), 4)]\n",
      " |  \n",
      " |  ground_roots(f)\n",
      " |      Compute roots of ``f`` by factorization in the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**6 - 4*x**4 + 4*x**3 - x**2).ground_roots()\n",
      " |      {0: 2, 1: 2}\n",
      " |  \n",
      " |  half_gcdex(f, g, auto=True)\n",
      " |      Half extended Euclidean algorithm of ``f`` and ``g``.\n",
      " |      \n",
      " |      Returns ``(s, h)`` such that ``h = gcd(f, g)`` and ``s*f = h (mod g)``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = x**4 - 2*x**3 - 6*x**2 + 12*x + 15\n",
      " |      >>> g = x**3 + x**2 - 4*x - 4\n",
      " |      \n",
      " |      >>> Poly(f).half_gcdex(Poly(g))\n",
      " |      (Poly(-1/5*x + 3/5, x, domain='QQ'), Poly(x + 1, x, domain='QQ'))\n",
      " |  \n",
      " |  has_only_gens(f, *gens)\n",
      " |      Return ``True`` if ``Poly(f, *gens)`` retains ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> Poly(x*y + 1, x, y, z).has_only_gens(x, y)\n",
      " |      True\n",
      " |      >>> Poly(x*y + z, x, y, z).has_only_gens(x, y)\n",
      " |      False\n",
      " |  \n",
      " |  homogeneous_order(f)\n",
      " |      Returns the homogeneous order of ``f``.\n",
      " |      \n",
      " |      A homogeneous polynomial is a polynomial whose all monomials with\n",
      " |      non-zero coefficients have the same total degree. This degree is\n",
      " |      the homogeneous order of ``f``. If you only want to check if a\n",
      " |      polynomial is homogeneous, then use :func:`Poly.is_homogeneous`.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = Poly(x**5 + 2*x**3*y**2 + 9*x*y**4)\n",
      " |      >>> f.homogeneous_order()\n",
      " |      5\n",
      " |  \n",
      " |  homogenize(f, s)\n",
      " |      Returns the homogeneous polynomial of ``f``.\n",
      " |      \n",
      " |      A homogeneous polynomial is a polynomial whose all monomials with\n",
      " |      non-zero coefficients have the same total degree. If you only\n",
      " |      want to check if a polynomial is homogeneous, then use\n",
      " |      :func:`Poly.is_homogeneous`. If you want not only to check if a\n",
      " |      polynomial is homogeneous but also compute its homogeneous order,\n",
      " |      then use :func:`Poly.homogeneous_order`.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> f = Poly(x**5 + 2*x**2*y**2 + 9*x*y**3)\n",
      " |      >>> f.homogenize(z)\n",
      " |      Poly(x**5 + 2*x**2*y**2*z + 9*x*y**3*z, x, y, z, domain='ZZ')\n",
      " |  \n",
      " |  inject(f, front=False)\n",
      " |      Inject ground domain generators into ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = Poly(x**2*y + x*y**3 + x*y + 1, x)\n",
      " |      \n",
      " |      >>> f.inject()\n",
      " |      Poly(x**2*y + x*y**3 + x*y + 1, x, y, domain='ZZ')\n",
      " |      >>> f.inject(front=True)\n",
      " |      Poly(y**3*x + y*x**2 + y*x + 1, y, x, domain='ZZ')\n",
      " |  \n",
      " |  integrate(self, *specs, **args)\n",
      " |      Computes indefinite integral of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x + 1, x).integrate()\n",
      " |      Poly(1/3*x**3 + x**2 + x, x, domain='QQ')\n",
      " |      \n",
      " |      >>> Poly(x*y**2 + x, x, y).integrate((0, 1), (1, 0))\n",
      " |      Poly(1/2*x**2*y**2 + 1/2*x**2, x, y, domain='QQ')\n",
      " |  \n",
      " |  intervals(f, all=False, eps=None, inf=None, sup=None, fast=False, sqf=False)\n",
      " |      Compute isolating intervals for roots of ``f``.\n",
      " |      \n",
      " |      For real roots the Vincent-Akritas-Strzebonski (VAS) continued fractions method is used.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [#] Alkiviadis G. Akritas and Adam W. Strzebonski: A Comparative Study of Two Real Root\n",
      " |          Isolation Methods . Nonlinear Analysis: Modelling and Control, Vol. 10, No. 4, 297-304, 2005.\n",
      " |      .. [#] Alkiviadis G. Akritas, Adam W. Strzebonski and Panagiotis S. Vigklas: Improving the\n",
      " |          Performance of the Continued Fractions Method Using new Bounds of Positive Roots. Nonlinear\n",
      " |          Analysis: Modelling and Control, Vol. 13, No. 3, 265-279, 2008.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 3, x).intervals()\n",
      " |      [((-2, -1), 1), ((1, 2), 1)]\n",
      " |      >>> Poly(x**2 - 3, x).intervals(eps=1e-2)\n",
      " |      [((-26/15, -19/11), 1), ((19/11, 26/15), 1)]\n",
      " |  \n",
      " |  invert(f, g, auto=True)\n",
      " |      Invert ``f`` modulo ``g`` when possible.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).invert(Poly(2*x - 1, x))\n",
      " |      Poly(-4/3, x, domain='QQ')\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).invert(Poly(x - 1, x))\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      NotInvertible: zero divisor\n",
      " |  \n",
      " |  l1_norm(f)\n",
      " |      Returns l1 norm of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(-x**2 + 2*x - 3, x).l1_norm()\n",
      " |      6\n",
      " |  \n",
      " |  lcm(f, g)\n",
      " |      Returns polynomial LCM of ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).lcm(Poly(x**2 - 3*x + 2, x))\n",
      " |      Poly(x**3 - 2*x**2 - x + 2, x, domain='ZZ')\n",
      " |  \n",
      " |  length(f)\n",
      " |      Returns the number of non-zero terms in ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x - 1).length()\n",
      " |      3\n",
      " |  \n",
      " |  lift(f)\n",
      " |      Convert algebraic coefficients to rationals.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + I*x + 1, x, extension=I).lift()\n",
      " |      Poly(x**4 + 3*x**2 + 1, x, domain='QQ')\n",
      " |  \n",
      " |  ltrim(f, gen)\n",
      " |      Remove dummy generators from ``f`` that are to the left of\n",
      " |      specified ``gen`` in the generators as ordered. When ``gen``\n",
      " |      is an integer, it refers to the generator located at that\n",
      " |      position within the tuple of generators of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> Poly(y**2 + y*z**2, x, y, z).ltrim(y)\n",
      " |      Poly(y**2 + y*z**2, y, z, domain='ZZ')\n",
      " |      >>> Poly(z, x, y, z).ltrim(-1)\n",
      " |      Poly(z, z, domain='ZZ')\n",
      " |  \n",
      " |  match(f, *args, **kwargs)\n",
      " |      Match expression from Poly. See Basic.match()\n",
      " |  \n",
      " |  max_norm(f)\n",
      " |      Returns maximum norm of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(-x**2 + 2*x - 3, x).max_norm()\n",
      " |      3\n",
      " |  \n",
      " |  monic(self, auto=True)\n",
      " |      Divides all coefficients by ``LC(f)``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, ZZ\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(3*x**2 + 6*x + 9, x, domain=ZZ).monic()\n",
      " |      Poly(x**2 + 2*x + 3, x, domain='QQ')\n",
      " |      \n",
      " |      >>> Poly(3*x**2 + 4*x + 2, x, domain=ZZ).monic()\n",
      " |      Poly(x**2 + 4/3*x + 2/3, x, domain='QQ')\n",
      " |  \n",
      " |  monoms(f, order=None)\n",
      " |      Returns all non-zero monomials from ``f`` in lex order.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).monoms()\n",
      " |      [(2, 0), (1, 2), (1, 1), (0, 1)]\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      all_monoms\n",
      " |  \n",
      " |  mul(f, g)\n",
      " |      Multiply two polynomials ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).mul(Poly(x - 2, x))\n",
      " |      Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x)*Poly(x - 2, x)\n",
      " |      Poly(x**3 - 2*x**2 + x - 2, x, domain='ZZ')\n",
      " |  \n",
      " |  mul_ground(f, coeff)\n",
      " |      Multiply ``f`` by a an element of the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x + 1).mul_ground(2)\n",
      " |      Poly(2*x + 2, x, domain='ZZ')\n",
      " |  \n",
      " |  ne(f, g, strict=False)\n",
      " |  \n",
      " |  neg(f)\n",
      " |      Negate all coefficients in ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).neg()\n",
      " |      Poly(-x**2 + 1, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> -Poly(x**2 - 1, x)\n",
      " |      Poly(-x**2 + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  norm(f)\n",
      " |      Computes the product, ``Norm(f)``, of the conjugates of\n",
      " |      a polynomial ``f`` defined over a number field ``K``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> a, b = sqrt(2), sqrt(3)\n",
      " |      \n",
      " |      A polynomial over a quadratic extension.\n",
      " |      Two conjugates x - a and x + a.\n",
      " |      \n",
      " |      >>> f = Poly(x - a, x, extension=a)\n",
      " |      >>> f.norm()\n",
      " |      Poly(x**2 - 2, x, domain='QQ')\n",
      " |      \n",
      " |      A polynomial over a quartic extension.\n",
      " |      Four conjugates x - a, x - a, x + a and x + a.\n",
      " |      \n",
      " |      >>> f = Poly(x - a, x, extension=(a, b))\n",
      " |      >>> f.norm()\n",
      " |      Poly(x**4 - 4*x**2 + 4, x, domain='QQ')\n",
      " |  \n",
      " |  nroots(f, n=15, maxsteps=50, cleanup=True)\n",
      " |      Compute numerical approximations of roots of ``f``.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      n ... the number of digits to calculate\n",
      " |      maxsteps ... the maximum number of iterations to do\n",
      " |      \n",
      " |      If the accuracy `n` cannot be reached in `maxsteps`, it will raise an\n",
      " |      exception. You need to rerun with higher maxsteps.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 3).nroots(n=15)\n",
      " |      [-1.73205080756888, 1.73205080756888]\n",
      " |      >>> Poly(x**2 - 3).nroots(n=30)\n",
      " |      [-1.73205080756887729352744634151, 1.73205080756887729352744634151]\n",
      " |  \n",
      " |  nth(f, *N)\n",
      " |      Returns the ``n``-th coefficient of ``f`` where ``N`` are the\n",
      " |      exponents of the generators in the term of interest.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, sqrt\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**3 + 2*x**2 + 3*x, x).nth(2)\n",
      " |      2\n",
      " |      >>> Poly(x**3 + 2*x*y**2 + y**2, x, y).nth(1, 2)\n",
      " |      2\n",
      " |      >>> Poly(4*sqrt(x)*y)\n",
      " |      Poly(4*y*(sqrt(x)), y, sqrt(x), domain='ZZ')\n",
      " |      >>> _.nth(1, 1)\n",
      " |      4\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      coeff_monomial\n",
      " |  \n",
      " |  nth_power_roots_poly(f, n)\n",
      " |      Construct a polynomial with n-th powers of roots of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = Poly(x**4 - x**2 + 1)\n",
      " |      \n",
      " |      >>> f.nth_power_roots_poly(2)\n",
      " |      Poly(x**4 - 2*x**3 + 3*x**2 - 2*x + 1, x, domain='ZZ')\n",
      " |      >>> f.nth_power_roots_poly(3)\n",
      " |      Poly(x**4 + 2*x**2 + 1, x, domain='ZZ')\n",
      " |      >>> f.nth_power_roots_poly(4)\n",
      " |      Poly(x**4 + 2*x**3 + 3*x**2 + 2*x + 1, x, domain='ZZ')\n",
      " |      >>> f.nth_power_roots_poly(12)\n",
      " |      Poly(x**4 - 4*x**3 + 6*x**2 - 4*x + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  pdiv(f, g)\n",
      " |      Polynomial pseudo-division of ``f`` by ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).pdiv(Poly(2*x - 4, x))\n",
      " |      (Poly(2*x + 4, x, domain='ZZ'), Poly(20, x, domain='ZZ'))\n",
      " |  \n",
      " |  per(f, rep, gens=None, remove=None)\n",
      " |      Create a Poly out of the given representation.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, ZZ\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> from sympy.polys.polyclasses import DMP\n",
      " |      \n",
      " |      >>> a = Poly(x**2 + 1)\n",
      " |      \n",
      " |      >>> a.per(DMP([ZZ(1), ZZ(1)], ZZ), gens=[y])\n",
      " |      Poly(y + 1, y, domain='ZZ')\n",
      " |  \n",
      " |  pexquo(f, g)\n",
      " |      Polynomial exact pseudo-quotient of ``f`` by ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).pexquo(Poly(2*x - 2, x))\n",
      " |      Poly(2*x + 2, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).pexquo(Poly(2*x - 4, x))\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      ExactQuotientFailed: 2*x - 4 does not divide x**2 + 1\n",
      " |  \n",
      " |  pow(f, n)\n",
      " |      Raise ``f`` to a non-negative power ``n``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x - 2, x).pow(3)\n",
      " |      Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x - 2, x)**3\n",
      " |      Poly(x**3 - 6*x**2 + 12*x - 8, x, domain='ZZ')\n",
      " |  \n",
      " |  pquo(f, g)\n",
      " |      Polynomial pseudo-quotient of ``f`` by ``g``.\n",
      " |      \n",
      " |      See the Caveat note in the function prem(f, g).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).pquo(Poly(2*x - 4, x))\n",
      " |      Poly(2*x + 4, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).pquo(Poly(2*x - 2, x))\n",
      " |      Poly(2*x + 2, x, domain='ZZ')\n",
      " |  \n",
      " |  prem(f, g)\n",
      " |      Polynomial pseudo-remainder of ``f`` by ``g``.\n",
      " |      \n",
      " |      Caveat: The function prem(f, g, x) can be safely used to compute\n",
      " |        in Z[x] _only_ subresultant polynomial remainder sequences (prs's).\n",
      " |      \n",
      " |        To safely compute Euclidean and Sturmian prs's in Z[x]\n",
      " |        employ anyone of the corresponding functions found in\n",
      " |        the module sympy.polys.subresultants_qq_zz. The functions\n",
      " |        in the module with suffix _pg compute prs's in Z[x] employing\n",
      " |        rem(f, g, x), whereas the functions with suffix _amv\n",
      " |        compute prs's in Z[x] employing rem_z(f, g, x).\n",
      " |      \n",
      " |        The function rem_z(f, g, x) differs from prem(f, g, x) in that\n",
      " |        to compute the remainder polynomials in Z[x] it premultiplies\n",
      " |        the divident times the absolute value of the leading coefficient\n",
      " |        of the divisor raised to the power degree(f, x) - degree(g, x) + 1.\n",
      " |      \n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).prem(Poly(2*x - 4, x))\n",
      " |      Poly(20, x, domain='ZZ')\n",
      " |  \n",
      " |  primitive(f)\n",
      " |      Returns the content and a primitive form of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x**2 + 8*x + 12, x).primitive()\n",
      " |      (2, Poly(x**2 + 4*x + 6, x, domain='ZZ'))\n",
      " |  \n",
      " |  quo(f, g, auto=True)\n",
      " |      Computes polynomial quotient of ``f`` by ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).quo(Poly(2*x - 4, x))\n",
      " |      Poly(1/2*x + 1, x, domain='QQ')\n",
      " |      \n",
      " |      >>> Poly(x**2 - 1, x).quo(Poly(x - 1, x))\n",
      " |      Poly(x + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  quo_ground(f, coeff)\n",
      " |      Quotient of ``f`` by a an element of the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x + 4).quo_ground(2)\n",
      " |      Poly(x + 2, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(2*x + 3).quo_ground(2)\n",
      " |      Poly(x + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  rat_clear_denoms(self, g)\n",
      " |      Clear denominators in a rational function ``f/g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> f = Poly(x**2/y + 1, x)\n",
      " |      >>> g = Poly(x**3 + y, x)\n",
      " |      \n",
      " |      >>> p, q = f.rat_clear_denoms(g)\n",
      " |      \n",
      " |      >>> p\n",
      " |      Poly(x**2 + y, x, domain='ZZ[y]')\n",
      " |      >>> q\n",
      " |      Poly(y*x**3 + y**2, x, domain='ZZ[y]')\n",
      " |  \n",
      " |  real_roots(f, multiple=True, radicals=True)\n",
      " |      Return a list of real roots with multiplicities.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x**3 - 7*x**2 + 4*x + 4).real_roots()\n",
      " |      [-1/2, 2, 2]\n",
      " |      >>> Poly(x**3 + x + 1).real_roots()\n",
      " |      [CRootOf(x**3 + x + 1, 0)]\n",
      " |  \n",
      " |  refine_root(f, s, t, eps=None, steps=None, fast=False, check_sqf=False)\n",
      " |      Refine an isolating interval of a root to the given precision.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 3, x).refine_root(1, 2, eps=1e-2)\n",
      " |      (19/11, 26/15)\n",
      " |  \n",
      " |  rem(f, g, auto=True)\n",
      " |      Computes the polynomial remainder of ``f`` by ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x))\n",
      " |      Poly(5, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).rem(Poly(2*x - 4, x), auto=False)\n",
      " |      Poly(x**2 + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  reorder(f, *gens, **args)\n",
      " |      Efficiently apply new order of generators.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + x*y**2, x, y).reorder(y, x)\n",
      " |      Poly(y**2*x + x**2, y, x, domain='ZZ')\n",
      " |  \n",
      " |  replace(f, x, y=None, **_ignore)\n",
      " |      Replace ``x`` with ``y`` in generators list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).replace(x, y)\n",
      " |      Poly(y**2 + 1, y, domain='ZZ')\n",
      " |  \n",
      " |  resultant(f, g, includePRS=False)\n",
      " |      Computes the resultant of ``f`` and ``g`` via PRS.\n",
      " |      \n",
      " |      If includePRS=True, it includes the subresultant PRS in the result.\n",
      " |      Because the PRS is used to calculate the resultant, this is more\n",
      " |      efficient than calling :func:`subresultants` separately.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = Poly(x**2 + 1, x)\n",
      " |      \n",
      " |      >>> f.resultant(Poly(x**2 - 1, x))\n",
      " |      4\n",
      " |      >>> f.resultant(Poly(x**2 - 1, x), includePRS=True)\n",
      " |      (4, [Poly(x**2 + 1, x, domain='ZZ'), Poly(x**2 - 1, x, domain='ZZ'),\n",
      " |           Poly(-2, x, domain='ZZ')])\n",
      " |  \n",
      " |  retract(f, field=None)\n",
      " |      Recalculate the ground domain of a polynomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = Poly(x**2 + 1, x, domain='QQ[y]')\n",
      " |      >>> f\n",
      " |      Poly(x**2 + 1, x, domain='QQ[y]')\n",
      " |      \n",
      " |      >>> f.retract()\n",
      " |      Poly(x**2 + 1, x, domain='ZZ')\n",
      " |      >>> f.retract(field=True)\n",
      " |      Poly(x**2 + 1, x, domain='QQ')\n",
      " |  \n",
      " |  revert(f, n)\n",
      " |      Compute ``f**(-1)`` mod ``x**n``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(1, x).revert(2)\n",
      " |      Poly(1, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(1 + x, x).revert(1)\n",
      " |      Poly(1, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 - 2, x).revert(2)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      NotReversible: only units are reversible in a ring\n",
      " |      \n",
      " |      >>> Poly(1/x, x).revert(1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      PolynomialError: 1/x contains an element of the generators set\n",
      " |  \n",
      " |  root(f, index, radicals=True)\n",
      " |      Get an indexed root of a polynomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = Poly(2*x**3 - 7*x**2 + 4*x + 4)\n",
      " |      \n",
      " |      >>> f.root(0)\n",
      " |      -1/2\n",
      " |      >>> f.root(1)\n",
      " |      2\n",
      " |      >>> f.root(2)\n",
      " |      2\n",
      " |      >>> f.root(3)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      IndexError: root index out of [-3, 2] range, got 3\n",
      " |      \n",
      " |      >>> Poly(x**5 + x + 1).root(0)\n",
      " |      CRootOf(x**3 - x**2 + 1, 0)\n",
      " |  \n",
      " |  same_root(f, a, b)\n",
      " |      Decide whether two roots of this polynomial are equal.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, cyclotomic_poly, exp, I, pi\n",
      " |      >>> f = Poly(cyclotomic_poly(5))\n",
      " |      >>> r0 = exp(2*I*pi/5)\n",
      " |      >>> indices = [i for i, r in enumerate(f.all_roots()) if f.same_root(r, r0)]\n",
      " |      >>> print(indices)\n",
      " |      [3]\n",
      " |      \n",
      " |      Raises\n",
      " |      ======\n",
      " |      \n",
      " |      DomainError\n",
      " |          If the domain of the polynomial is not :ref:`ZZ`, :ref:`QQ`,\n",
      " |          :ref:`RR`, or :ref:`CC`.\n",
      " |      MultivariatePolynomialError\n",
      " |          If the polynomial is not univariate.\n",
      " |      PolynomialError\n",
      " |          If the polynomial is of degree < 2.\n",
      " |  \n",
      " |  set_domain(f, domain)\n",
      " |      Set the ground domain of ``f``.\n",
      " |  \n",
      " |  set_modulus(f, modulus)\n",
      " |      Set the modulus of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(5*x**2 + 2*x - 1, x).set_modulus(2)\n",
      " |      Poly(x**2 + 1, x, modulus=2)\n",
      " |  \n",
      " |  shift(f, a)\n",
      " |      Efficiently compute Taylor shift ``f(x + a)``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 2*x + 1, x).shift(2)\n",
      " |      Poly(x**2 + 2*x + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  slice(f, x, m, n=None)\n",
      " |      Take a continuous subsequence of terms of ``f``.\n",
      " |  \n",
      " |  sqf_list(f, all=False)\n",
      " |      Returns a list of square-free factors of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = 2*x**5 + 16*x**4 + 50*x**3 + 76*x**2 + 56*x + 16\n",
      " |      \n",
      " |      >>> Poly(f).sqf_list()\n",
      " |      (2, [(Poly(x + 1, x, domain='ZZ'), 2),\n",
      " |           (Poly(x + 2, x, domain='ZZ'), 3)])\n",
      " |      \n",
      " |      >>> Poly(f).sqf_list(all=True)\n",
      " |      (2, [(Poly(1, x, domain='ZZ'), 1),\n",
      " |           (Poly(x + 1, x, domain='ZZ'), 2),\n",
      " |           (Poly(x + 2, x, domain='ZZ'), 3)])\n",
      " |  \n",
      " |  sqf_list_include(f, all=False)\n",
      " |      Returns a list of square-free factors of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, expand\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = expand(2*(x + 1)**3*x**4)\n",
      " |      >>> f\n",
      " |      2*x**7 + 6*x**6 + 6*x**5 + 2*x**4\n",
      " |      \n",
      " |      >>> Poly(f).sqf_list_include()\n",
      " |      [(Poly(2, x, domain='ZZ'), 1),\n",
      " |       (Poly(x + 1, x, domain='ZZ'), 3),\n",
      " |       (Poly(x, x, domain='ZZ'), 4)]\n",
      " |      \n",
      " |      >>> Poly(f).sqf_list_include(all=True)\n",
      " |      [(Poly(2, x, domain='ZZ'), 1),\n",
      " |       (Poly(1, x, domain='ZZ'), 2),\n",
      " |       (Poly(x + 1, x, domain='ZZ'), 3),\n",
      " |       (Poly(x, x, domain='ZZ'), 4)]\n",
      " |  \n",
      " |  sqf_norm(f)\n",
      " |      Computes square-free norm of ``f``.\n",
      " |      \n",
      " |      Returns ``s``, ``f``, ``r``, such that ``g(x) = f(x-sa)`` and\n",
      " |      ``r(x) = Norm(g(x))`` is a square-free polynomial over ``K``,\n",
      " |      where ``a`` is the algebraic extension of the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, sqrt\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> s, f, r = Poly(x**2 + 1, x, extension=[sqrt(3)]).sqf_norm()\n",
      " |      \n",
      " |      >>> s\n",
      " |      1\n",
      " |      >>> f\n",
      " |      Poly(x**2 - 2*sqrt(3)*x + 4, x, domain='QQ<sqrt(3)>')\n",
      " |      >>> r\n",
      " |      Poly(x**4 - 4*x**2 + 16, x, domain='QQ')\n",
      " |  \n",
      " |  sqf_part(f)\n",
      " |      Computes square-free part of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 - 3*x - 2, x).sqf_part()\n",
      " |      Poly(x**2 - x - 2, x, domain='ZZ')\n",
      " |  \n",
      " |  sqr(f)\n",
      " |      Square a polynomial ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x - 2, x).sqr()\n",
      " |      Poly(x**2 - 4*x + 4, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x - 2, x)**2\n",
      " |      Poly(x**2 - 4*x + 4, x, domain='ZZ')\n",
      " |  \n",
      " |  sturm(self, auto=True)\n",
      " |      Computes the Sturm sequence of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**3 - 2*x**2 + x - 3, x).sturm()\n",
      " |      [Poly(x**3 - 2*x**2 + x - 3, x, domain='QQ'),\n",
      " |       Poly(3*x**2 - 4*x + 1, x, domain='QQ'),\n",
      " |       Poly(2/9*x + 25/9, x, domain='QQ'),\n",
      " |       Poly(-2079/4, x, domain='QQ')]\n",
      " |  \n",
      " |  sub(f, g)\n",
      " |      Subtract two polynomials ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).sub(Poly(x - 2, x))\n",
      " |      Poly(x**2 - x + 3, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x) - Poly(x - 2, x)\n",
      " |      Poly(x**2 - x + 3, x, domain='ZZ')\n",
      " |  \n",
      " |  sub_ground(f, coeff)\n",
      " |      Subtract an element of the ground domain from ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x + 1).sub_ground(2)\n",
      " |      Poly(x - 1, x, domain='ZZ')\n",
      " |  \n",
      " |  subresultants(f, g)\n",
      " |      Computes the subresultant PRS of ``f`` and ``g``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).subresultants(Poly(x**2 - 1, x))\n",
      " |      [Poly(x**2 + 1, x, domain='ZZ'),\n",
      " |       Poly(x**2 - 1, x, domain='ZZ'),\n",
      " |       Poly(-2, x, domain='ZZ')]\n",
      " |  \n",
      " |  terms(f, order=None)\n",
      " |      Returns all non-zero terms from ``f`` in lex order.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + 2*x*y**2 + x*y + 3*y, x, y).terms()\n",
      " |      [((2, 0), 1), ((1, 2), 2), ((1, 1), 1), ((0, 1), 3)]\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      all_terms\n",
      " |  \n",
      " |  terms_gcd(f)\n",
      " |      Remove GCD of terms from the polynomial ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**6*y**2 + x**3*y, x, y).terms_gcd()\n",
      " |      ((3, 1), Poly(x**3*y + 1, x, y, domain='ZZ'))\n",
      " |  \n",
      " |  termwise(f, func, *gens, **args)\n",
      " |      Apply a function to all terms of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> def func(k, coeff):\n",
      " |      ...     k = k[0]\n",
      " |      ...     return coeff//10**(2-k)\n",
      " |      \n",
      " |      >>> Poly(x**2 + 20*x + 400).termwise(func)\n",
      " |      Poly(x**2 + 2*x + 4, x, domain='ZZ')\n",
      " |  \n",
      " |  to_exact(f)\n",
      " |      Make the ground domain exact.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, RR\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1.0, x, domain=RR).to_exact()\n",
      " |      Poly(x**2 + 1, x, domain='QQ')\n",
      " |  \n",
      " |  to_field(f)\n",
      " |      Make the ground domain a field.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, ZZ\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x, domain=ZZ).to_field()\n",
      " |      Poly(x**2 + 1, x, domain='QQ')\n",
      " |  \n",
      " |  to_ring(f)\n",
      " |      Make the ground domain a ring.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, QQ\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, domain=QQ).to_ring()\n",
      " |      Poly(x**2 + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  total_degree(f)\n",
      " |      Returns the total degree of ``f``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + y*x + 1, x, y).total_degree()\n",
      " |      2\n",
      " |      >>> Poly(x + y**5, x, y).total_degree()\n",
      " |      5\n",
      " |  \n",
      " |  transform(f, p, q)\n",
      " |      Efficiently evaluate the functional transformation ``q**n * f(p/q)``.\n",
      " |      \n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 2*x + 1, x).transform(Poly(x + 1, x), Poly(x - 1, x))\n",
      " |      Poly(4, x, domain='ZZ')\n",
      " |  \n",
      " |  trunc(f, p)\n",
      " |      Reduce ``f`` modulo a constant ``p``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x**3 + 3*x**2 + 5*x + 7, x).trunc(3)\n",
      " |      Poly(-x**3 - x + 1, x, domain='ZZ')\n",
      " |  \n",
      " |  unify(f, g)\n",
      " |      Make ``f`` and ``g`` belong to the same domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f, g = Poly(x/2 + 1), Poly(2*x + 1)\n",
      " |      \n",
      " |      >>> f\n",
      " |      Poly(1/2*x + 1, x, domain='QQ')\n",
      " |      >>> g\n",
      " |      Poly(2*x + 1, x, domain='ZZ')\n",
      " |      \n",
      " |      >>> F, G = f.unify(g)\n",
      " |      \n",
      " |      >>> F\n",
      " |      Poly(1/2*x + 1, x, domain='QQ')\n",
      " |      >>> G\n",
      " |      Poly(2*x + 1, x, domain='QQ')\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  from_dict(rep, *gens, **args) from sympy.core.assumptions.ManagedProperties\n",
      " |      Construct a polynomial from a ``dict``.\n",
      " |  \n",
      " |  from_expr(rep, *gens, **args) from sympy.core.assumptions.ManagedProperties\n",
      " |      Construct a polynomial from an expression.\n",
      " |  \n",
      " |  from_list(rep, *gens, **args) from sympy.core.assumptions.ManagedProperties\n",
      " |      Construct a polynomial from a ``list``.\n",
      " |  \n",
      " |  from_poly(rep, *gens, **args) from sympy.core.assumptions.ManagedProperties\n",
      " |      Construct a polynomial from a polynomial.\n",
      " |  \n",
      " |  new(rep, *gens) from sympy.core.assumptions.ManagedProperties\n",
      " |      Construct :class:`Poly` instance from raw representation.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, rep, *gens, **args)\n",
      " |      Create a new polynomial instance out of something useful.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  domain\n",
      " |      Get the ground domain of a :py:class:`~.Poly`\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      :py:class:`~.Domain`:\n",
      " |          Ground domain of the :py:class:`~.Poly`.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly, Symbol\n",
      " |      >>> x = Symbol('x')\n",
      " |      >>> p = Poly(x**2 + x)\n",
      " |      >>> p\n",
      " |      Poly(x**2 + x, x, domain='ZZ')\n",
      " |      >>> p.domain\n",
      " |      ZZ\n",
      " |  \n",
      " |  expr\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Free symbols of a polynomial expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1).free_symbols\n",
      " |      {x}\n",
      " |      >>> Poly(x**2 + y).free_symbols\n",
      " |      {x, y}\n",
      " |      >>> Poly(x**2 + y, x).free_symbols\n",
      " |      {x, y}\n",
      " |      >>> Poly(x**2 + y, x, z).free_symbols\n",
      " |      {x, y}\n",
      " |  \n",
      " |  free_symbols_in_domain\n",
      " |      Free symbols of the domain of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1).free_symbols_in_domain\n",
      " |      set()\n",
      " |      >>> Poly(x**2 + y).free_symbols_in_domain\n",
      " |      set()\n",
      " |      >>> Poly(x**2 + y, x).free_symbols_in_domain\n",
      " |      {y}\n",
      " |  \n",
      " |  gen\n",
      " |      Return the principal generator.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + 1, x).gen\n",
      " |      x\n",
      " |  \n",
      " |  is_cyclotomic\n",
      " |      Returns ``True`` if ``f`` is a cyclotomic polnomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> f = x**16 + x**14 - x**10 + x**8 - x**6 + x**2 + 1\n",
      " |      \n",
      " |      >>> Poly(f).is_cyclotomic\n",
      " |      False\n",
      " |      \n",
      " |      >>> g = x**16 + x**14 - x**10 - x**8 - x**6 + x**2 + 1\n",
      " |      \n",
      " |      >>> Poly(g).is_cyclotomic\n",
      " |      True\n",
      " |  \n",
      " |  is_ground\n",
      " |      Returns ``True`` if ``f`` is an element of the ground domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x, x).is_ground\n",
      " |      False\n",
      " |      >>> Poly(2, x).is_ground\n",
      " |      True\n",
      " |      >>> Poly(y, x).is_ground\n",
      " |      True\n",
      " |  \n",
      " |  is_homogeneous\n",
      " |      Returns ``True`` if ``f`` is a homogeneous polynomial.\n",
      " |      \n",
      " |      A homogeneous polynomial is a polynomial whose all monomials with\n",
      " |      non-zero coefficients have the same total degree. If you want not\n",
      " |      only to check if a polynomial is homogeneous but also compute its\n",
      " |      homogeneous order, then use :func:`Poly.homogeneous_order`.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + x*y, x, y).is_homogeneous\n",
      " |      True\n",
      " |      >>> Poly(x**3 + x*y, x, y).is_homogeneous\n",
      " |      False\n",
      " |  \n",
      " |  is_irreducible\n",
      " |      Returns ``True`` if ``f`` has no factors over its domain.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 + x + 1, x, modulus=2).is_irreducible\n",
      " |      True\n",
      " |      >>> Poly(x**2 + 1, x, modulus=2).is_irreducible\n",
      " |      False\n",
      " |  \n",
      " |  is_linear\n",
      " |      Returns ``True`` if ``f`` is linear in all its variables.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x + y + 2, x, y).is_linear\n",
      " |      True\n",
      " |      >>> Poly(x*y + 2, x, y).is_linear\n",
      " |      False\n",
      " |  \n",
      " |  is_monic\n",
      " |      Returns ``True`` if the leading coefficient of ``f`` is one.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x + 2, x).is_monic\n",
      " |      True\n",
      " |      >>> Poly(2*x + 2, x).is_monic\n",
      " |      False\n",
      " |  \n",
      " |  is_monomial\n",
      " |      Returns ``True`` if ``f`` is zero or has only one term.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(3*x**2, x).is_monomial\n",
      " |      True\n",
      " |      >>> Poly(3*x**2 + 1, x).is_monomial\n",
      " |      False\n",
      " |  \n",
      " |  is_multivariate\n",
      " |      Returns ``True`` if ``f`` is a multivariate polynomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + x + 1, x).is_multivariate\n",
      " |      False\n",
      " |      >>> Poly(x*y**2 + x*y + 1, x, y).is_multivariate\n",
      " |      True\n",
      " |      >>> Poly(x*y**2 + x*y + 1, x).is_multivariate\n",
      " |      False\n",
      " |      >>> Poly(x**2 + x + 1, x, y).is_multivariate\n",
      " |      True\n",
      " |  \n",
      " |  is_one\n",
      " |      Returns ``True`` if ``f`` is a unit polynomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(0, x).is_one\n",
      " |      False\n",
      " |      >>> Poly(1, x).is_one\n",
      " |      True\n",
      " |  \n",
      " |  is_primitive\n",
      " |      Returns ``True`` if GCD of the coefficients of ``f`` is one.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(2*x**2 + 6*x + 12, x).is_primitive\n",
      " |      False\n",
      " |      >>> Poly(x**2 + 3*x + 6, x).is_primitive\n",
      " |      True\n",
      " |  \n",
      " |  is_quadratic\n",
      " |      Returns ``True`` if ``f`` is quadratic in all its variables.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x*y + 2, x, y).is_quadratic\n",
      " |      True\n",
      " |      >>> Poly(x*y**2 + 2, x, y).is_quadratic\n",
      " |      False\n",
      " |  \n",
      " |  is_sqf\n",
      " |      Returns ``True`` if ``f`` is a square-free polynomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(x**2 - 2*x + 1, x).is_sqf\n",
      " |      False\n",
      " |      >>> Poly(x**2 - 1, x).is_sqf\n",
      " |      True\n",
      " |  \n",
      " |  is_univariate\n",
      " |      Returns ``True`` if ``f`` is a univariate polynomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> Poly(x**2 + x + 1, x).is_univariate\n",
      " |      True\n",
      " |      >>> Poly(x*y**2 + x*y + 1, x, y).is_univariate\n",
      " |      False\n",
      " |      >>> Poly(x*y**2 + x*y + 1, x).is_univariate\n",
      " |      True\n",
      " |      >>> Poly(x**2 + x + 1, x, y).is_univariate\n",
      " |      False\n",
      " |  \n",
      " |  is_zero\n",
      " |      Returns ``True`` if ``f`` is a zero polynomial.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Poly\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Poly(0, x).is_zero\n",
      " |      True\n",
      " |      >>> Poly(1, x).is_zero\n",
      " |      False\n",
      " |  \n",
      " |  one\n",
      " |      Return one polynomial with ``self``'s properties.\n",
      " |  \n",
      " |  unit\n",
      " |      Return unit polynomial with ``self``'s properties.\n",
      " |  \n",
      " |  zero\n",
      " |      Return zero polynomial with ``self``'s properties.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  gens\n",
      " |  \n",
      " |  rep\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {'commutative': True}\n",
      " |  \n",
      " |  is_Poly = True\n",
      " |  \n",
      " |  is_commutative = True\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'tuple[Basic, ...]', '_mhash': 'int | None...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  kind = UndefinedKind\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(Poly)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "id": "7cab273b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-1, 0\\right) \\cup \\left[1, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.Ropen(-1, 0), Interval(1, oo))"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(t>=1/t,t,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "id": "9ba2e9af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 1 - \\sqrt{2}\\right] \\cup \\left(0, 1 + \\sqrt{2}\\right]$"
      ],
      "text/plain": [
       "Union(Interval(-oo, 1 - sqrt(2)), Interval.Lopen(0, 1 + sqrt(2)))"
      ]
     },
     "execution_count": 303,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(t-2<=1/t,t,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "id": "5be57080",
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class ConditionSet in module sympy.sets.conditionset:\n",
      "\n",
      "class ConditionSet(sympy.sets.sets.Set)\n",
      " |  ConditionSet(sym, condition, base_set=UniversalSet)\n",
      " |  \n",
      " |  Set of elements which satisfies a given condition.\n",
      " |  \n",
      " |  .. math:: \\{x \\mid \\textrm{condition}(x) = \\texttt{True}, x \\in S\\}\n",
      " |  \n",
      " |  Examples\n",
      " |  ========\n",
      " |  \n",
      " |  >>> from sympy import Symbol, S, ConditionSet, pi, Eq, sin, Interval\n",
      " |  >>> from sympy.abc import x, y, z\n",
      " |  \n",
      " |  >>> sin_sols = ConditionSet(x, Eq(sin(x), 0), Interval(0, 2*pi))\n",
      " |  >>> 2*pi in sin_sols\n",
      " |  True\n",
      " |  >>> pi/2 in sin_sols\n",
      " |  False\n",
      " |  >>> 3*pi in sin_sols\n",
      " |  False\n",
      " |  >>> 5 in ConditionSet(x, x**2 > 4, S.Reals)\n",
      " |  True\n",
      " |  \n",
      " |  If the value is not in the base set, the result is false:\n",
      " |  \n",
      " |  >>> 5 in ConditionSet(x, x**2 > 4, Interval(2, 4))\n",
      " |  False\n",
      " |  \n",
      " |  Notes\n",
      " |  =====\n",
      " |  \n",
      " |  Symbols with assumptions should be avoided or else the\n",
      " |  condition may evaluate without consideration of the set:\n",
      " |  \n",
      " |  >>> n = Symbol('n', negative=True)\n",
      " |  >>> cond = (n > 0); cond\n",
      " |  False\n",
      " |  >>> ConditionSet(n, cond, S.Integers)\n",
      " |  EmptySet\n",
      " |  \n",
      " |  Only free symbols can be changed by using `subs`:\n",
      " |  \n",
      " |  >>> c = ConditionSet(x, x < 1, {x, z})\n",
      " |  >>> c.subs(x, y)\n",
      " |  ConditionSet(x, x < 1, {y, z})\n",
      " |  \n",
      " |  To check if ``pi`` is in ``c`` use:\n",
      " |  \n",
      " |  >>> pi in c\n",
      " |  False\n",
      " |  \n",
      " |  If no base set is specified, the universal set is implied:\n",
      " |  \n",
      " |  >>> ConditionSet(x, x < 1).base_set\n",
      " |  UniversalSet\n",
      " |  \n",
      " |  Only symbols or symbol-like expressions can be used:\n",
      " |  \n",
      " |  >>> ConditionSet(x + 1, x + 1 < 1, S.Integers)\n",
      " |  Traceback (most recent call last):\n",
      " |  ...\n",
      " |  ValueError: non-symbol dummy not recognized in condition\n",
      " |  \n",
      " |  When the base set is a ConditionSet, the symbols will be\n",
      " |  unified if possible with preference for the outermost symbols:\n",
      " |  \n",
      " |  >>> ConditionSet(x, x < y, ConditionSet(z, z + y < 2, S.Integers))\n",
      " |  ConditionSet(x, (x < y) & (x + y < 2), Integers)\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      ConditionSet\n",
      " |      sympy.sets.sets.Set\n",
      " |      sympy.core.basic.Basic\n",
      " |      sympy.printing.defaults.Printable\n",
      " |      sympy.core.evalf.EvalfMixin\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  as_relational(self, other)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(cls, sym, condition, base_set=UniversalSet)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  __sympy__\n",
      " |  \n",
      " |  base_set\n",
      " |  \n",
      " |  bound_symbols\n",
      " |  \n",
      " |  condition\n",
      " |  \n",
      " |  free_symbols\n",
      " |      Return from the atoms of self those which are free symbols.\n",
      " |      \n",
      " |      Not all free symbols are ``Symbol``. Eg: IndexedBase('I')[0].free_symbols\n",
      " |      \n",
      " |      For most expressions, all symbols are free symbols. For some classes\n",
      " |      this is not true. e.g. Integrals use Symbols for the dummy variables\n",
      " |      which are bound variables, so Integral has a method to return all\n",
      " |      symbols except those. Derivative keeps track of symbols with respect\n",
      " |      to which it will perform a derivative; those are\n",
      " |      bound variables, too, so it has its own free_symbols method.\n",
      " |      \n",
      " |      Any other method that uses bound variables should implement a\n",
      " |      free_symbols method.\n",
      " |  \n",
      " |  sym\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  default_assumptions = {}\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  __add__(self, other)\n",
      " |  \n",
      " |  __and__(self, other)\n",
      " |  \n",
      " |  __contains__(self, other)\n",
      " |  \n",
      " |  __mul__(self, other)\n",
      " |  \n",
      " |  __or__(self, other)\n",
      " |  \n",
      " |  __pow__(self, exp)\n",
      " |  \n",
      " |  __sub__(self, other)\n",
      " |  \n",
      " |  __xor__(self, other)\n",
      " |  \n",
      " |  complement(self, universe)\n",
      " |      The complement of 'self' w.r.t the given universe.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(0, 1).complement(S.Reals)\n",
      " |      Union(Interval.open(-oo, 0), Interval.open(1, oo))\n",
      " |      \n",
      " |      >>> Interval(0, 1).complement(S.UniversalSet)\n",
      " |      Complement(UniversalSet, Interval(0, 1))\n",
      " |  \n",
      " |  contains(self, other)\n",
      " |      Returns a SymPy value indicating whether ``other`` is contained\n",
      " |      in ``self``: ``true`` if it is, ``false`` if it is not, else\n",
      " |      an unevaluated ``Contains`` expression (or, as in the case of\n",
      " |      ConditionSet and a union of FiniteSet/Intervals, an expression\n",
      " |      indicating the conditions for containment).\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(0.5)\n",
      " |      True\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``in`` operator, but that\n",
      " |      will raise an error unless an affirmative true or false is not\n",
      " |      obtained.\n",
      " |      \n",
      " |      >>> Interval(0, 1).contains(x)\n",
      " |      (0 <= x) & (x <= 1)\n",
      " |      >>> x in Interval(0, 1)\n",
      " |      Traceback (most recent call last):\n",
      " |      ...\n",
      " |      TypeError: did not evaluate to a bool: None\n",
      " |      \n",
      " |      The result of 'in' is a bool, not a SymPy value\n",
      " |      \n",
      " |      >>> 1 in Interval(0, 2)\n",
      " |      True\n",
      " |      >>> _ is S.true\n",
      " |      False\n",
      " |  \n",
      " |  intersect(self, other)\n",
      " |      Returns the intersection of 'self' and 'other'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      \n",
      " |      >>> Interval(1, 3).intersect(Interval(1, 2))\n",
      " |      Interval(1, 2)\n",
      " |      \n",
      " |      >>> from sympy import imageset, Lambda, symbols, S\n",
      " |      >>> n, m = symbols('n m')\n",
      " |      >>> a = imageset(Lambda(n, 2*n), S.Integers)\n",
      " |      >>> a.intersect(imageset(Lambda(m, 2*m + 1), S.Integers))\n",
      " |      EmptySet\n",
      " |  \n",
      " |  intersection(self, other)\n",
      " |      Alias for :meth:`intersect()`\n",
      " |  \n",
      " |  is_disjoint(self, other)\n",
      " |      Returns True if ``self`` and ``other`` are disjoint.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(1, 2))\n",
      " |      False\n",
      " |      >>> Interval(0, 2).is_disjoint(Interval(3, 4))\n",
      " |      True\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Disjoint_sets\n",
      " |  \n",
      " |  is_proper_subset(self, other)\n",
      " |      Returns True if ``self`` is a proper subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_proper_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_subset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_proper_superset(self, other)\n",
      " |      Returns True if ``self`` is a proper superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 0.5))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_proper_superset(Interval(0, 1))\n",
      " |      False\n",
      " |  \n",
      " |  is_subset(self, other)\n",
      " |      Returns True if ``self`` is a subset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_subset(Interval(0, 1))\n",
      " |      True\n",
      " |      >>> Interval(0, 1).is_subset(Interval(0, 1, left_open=True))\n",
      " |      False\n",
      " |  \n",
      " |  is_superset(self, other)\n",
      " |      Returns True if ``self`` is a superset of ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 0.5).is_superset(Interval(0, 1))\n",
      " |      False\n",
      " |      >>> Interval(0, 1).is_superset(Interval(0, 1, left_open=True))\n",
      " |      True\n",
      " |  \n",
      " |  isdisjoint(self, other)\n",
      " |      Alias for :meth:`is_disjoint()`\n",
      " |  \n",
      " |  issubset(self, other)\n",
      " |      Alias for :meth:`is_subset()`\n",
      " |  \n",
      " |  issuperset(self, other)\n",
      " |      Alias for :meth:`is_superset()`\n",
      " |  \n",
      " |  powerset(self)\n",
      " |      Find the Power set of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import EmptySet, FiniteSet, Interval\n",
      " |      \n",
      " |      A power set of an empty set:\n",
      " |      \n",
      " |      >>> A = EmptySet\n",
      " |      >>> A.powerset()\n",
      " |      {EmptySet}\n",
      " |      \n",
      " |      A power set of a finite set:\n",
      " |      \n",
      " |      >>> A = FiniteSet(1, 2)\n",
      " |      >>> a, b, c = FiniteSet(1), FiniteSet(2), FiniteSet(1, 2)\n",
      " |      >>> A.powerset() == FiniteSet(a, b, c, EmptySet)\n",
      " |      True\n",
      " |      \n",
      " |      A power set of an interval:\n",
      " |      \n",
      " |      >>> Interval(1, 2).powerset()\n",
      " |      PowerSet(Interval(1, 2))\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      .. [1] https://en.wikipedia.org/wiki/Power_set\n",
      " |  \n",
      " |  symmetric_difference(self, other)\n",
      " |      Returns symmetric difference of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, S\n",
      " |      >>> Interval(1, 3).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(3, oo))\n",
      " |      >>> Interval(1, 10).symmetric_difference(S.Reals)\n",
      " |      Union(Interval.open(-oo, 1), Interval.open(10, oo))\n",
      " |      \n",
      " |      >>> from sympy import S, EmptySet\n",
      " |      >>> S.Reals.symmetric_difference(EmptySet)\n",
      " |      Reals\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      .. [1] https://en.wikipedia.org/wiki/Symmetric_difference\n",
      " |  \n",
      " |  union(self, other)\n",
      " |      Returns the union of ``self`` and ``other``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      As a shortcut it is possible to use the ``+`` operator:\n",
      " |      \n",
      " |      >>> from sympy import Interval, FiniteSet\n",
      " |      >>> Interval(0, 1).union(Interval(2, 3))\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(0, 1) + Interval(2, 3)\n",
      " |      Union(Interval(0, 1), Interval(2, 3))\n",
      " |      >>> Interval(1, 2, True, True) + FiniteSet(2, 3)\n",
      " |      Union({3}, Interval.Lopen(1, 2))\n",
      " |      \n",
      " |      Similarly it is possible to use the ``-`` operator for set differences:\n",
      " |      \n",
      " |      >>> Interval(0, 2) - Interval(0, 1)\n",
      " |      Interval.Lopen(1, 2)\n",
      " |      >>> Interval(1, 3) - FiniteSet(2)\n",
      " |      Union(Interval.Ropen(1, 2), Interval.Lopen(2, 3))\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  boundary\n",
      " |      The boundary or frontier of a set.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A point x is on the boundary of a set S if\n",
      " |      \n",
      " |      1.  x is in the closure of S.\n",
      " |          I.e. Every neighborhood of x contains a point in S.\n",
      " |      2.  x is not in the interior of S.\n",
      " |          I.e. There does not exist an open set centered on x contained\n",
      " |          entirely within S.\n",
      " |      \n",
      " |      There are the points on the outer rim of S.  If S is open then these\n",
      " |      points need not actually be contained within S.\n",
      " |      \n",
      " |      For example, the boundary of an interval is its start and end points.\n",
      " |      This is true regardless of whether or not the interval is open.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).boundary\n",
      " |      {0, 1}\n",
      " |      >>> Interval(0, 1, True, False).boundary\n",
      " |      {0, 1}\n",
      " |  \n",
      " |  closure\n",
      " |      Property method which returns the closure of a set.\n",
      " |      The closure is defined as the union of the set itself and its\n",
      " |      boundary.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S, Interval\n",
      " |      >>> S.Reals.closure\n",
      " |      Reals\n",
      " |      >>> Interval(0, 1).closure\n",
      " |      Interval(0, 1)\n",
      " |  \n",
      " |  inf\n",
      " |      The infimum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).inf\n",
      " |      0\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).inf\n",
      " |      0\n",
      " |  \n",
      " |  interior\n",
      " |      Property method which returns the interior of a set.\n",
      " |      The interior of a set S consists all points of S that do not\n",
      " |      belong to the boundary of S.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).interior\n",
      " |      Interval.open(0, 1)\n",
      " |      >>> Interval(0, 1).boundary.interior\n",
      " |      EmptySet\n",
      " |  \n",
      " |  is_EmptySet\n",
      " |  \n",
      " |  is_closed\n",
      " |      A property method to check whether a set is closed.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is closed if its complement is an open set. The closedness of a\n",
      " |      subset of the reals is determined with respect to R and its standard\n",
      " |      topology.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import Interval\n",
      " |      >>> Interval(0, 1).is_closed\n",
      " |      True\n",
      " |  \n",
      " |  is_open\n",
      " |      Property method to check whether a set is open.\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      A set is open if and only if it has an empty intersection with its\n",
      " |      boundary. In particular, a subset A of the reals is open if and only\n",
      " |      if each one of its points is contained in an open interval that is a\n",
      " |      subset of A.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      >>> from sympy import S\n",
      " |      >>> S.Reals.is_open\n",
      " |      True\n",
      " |      >>> S.Rationals.is_open\n",
      " |      False\n",
      " |  \n",
      " |  kind\n",
      " |      The kind of a Set\n",
      " |      \n",
      " |      Explanation\n",
      " |      ===========\n",
      " |      \n",
      " |      Any :class:`Set` will have kind :class:`SetKind` which is\n",
      " |      parametrised by the kind of the elements of the set. For example\n",
      " |      most sets are sets of numbers and will have kind\n",
      " |      ``SetKind(NumberKind)``. If elements of sets are different in kind than\n",
      " |      their kind will ``SetKind(UndefinedKind)``. See\n",
      " |      :class:`sympy.core.kind.Kind` for an explanation of the kind system.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Matrix, FiniteSet, EmptySet, ProductSet, PowerSet\n",
      " |      \n",
      " |      >>> FiniteSet(Matrix([1, 2])).kind\n",
      " |      SetKind(MatrixKind(NumberKind))\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind\n",
      " |      SetKind(NumberKind)\n",
      " |      \n",
      " |      >>> EmptySet.kind\n",
      " |      SetKind()\n",
      " |      \n",
      " |      A :class:`sympy.sets.powerset.PowerSet` is a set of sets:\n",
      " |      \n",
      " |      >>> PowerSet({1, 2, 3}).kind\n",
      " |      SetKind(SetKind(NumberKind))\n",
      " |      \n",
      " |      A :class:`ProductSet` represents the set of tuples of elements of\n",
      " |      other sets. Its kind is :class:`sympy.core.containers.TupleKind`\n",
      " |      parametrised by the kinds of the elements of those sets:\n",
      " |      \n",
      " |      >>> p = ProductSet(FiniteSet(1, 2), FiniteSet(3, 4))\n",
      " |      >>> list(p)\n",
      " |      [(1, 3), (2, 3), (1, 4), (2, 4)]\n",
      " |      >>> p.kind\n",
      " |      SetKind(TupleKind(NumberKind, NumberKind))\n",
      " |      \n",
      " |      When all elements of the set do not have same kind, the kind\n",
      " |      will be returned as ``SetKind(UndefinedKind)``:\n",
      " |      \n",
      " |      >>> FiniteSet(0, Matrix([1, 2])).kind\n",
      " |      SetKind(UndefinedKind)\n",
      " |      \n",
      " |      The kind of the elements of a set are given by the ``element_kind``\n",
      " |      attribute of ``SetKind``:\n",
      " |      \n",
      " |      >>> Interval(1, 2).kind.element_kind\n",
      " |      NumberKind\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      NumberKind\n",
      " |      sympy.core.kind.UndefinedKind\n",
      " |      sympy.core.containers.TupleKind\n",
      " |      MatrixKind\n",
      " |      sympy.matrices.expressions.sets.MatrixSet\n",
      " |      sympy.sets.conditionset.ConditionSet\n",
      " |      Rationals\n",
      " |      Naturals\n",
      " |      Integers\n",
      " |      sympy.sets.fancysets.ImageSet\n",
      " |      sympy.sets.fancysets.Range\n",
      " |      sympy.sets.fancysets.ComplexRegion\n",
      " |      sympy.sets.powerset.PowerSet\n",
      " |      sympy.sets.sets.ProductSet\n",
      " |      sympy.sets.sets.Interval\n",
      " |      sympy.sets.sets.Union\n",
      " |      sympy.sets.sets.Intersection\n",
      " |      sympy.sets.sets.Complement\n",
      " |      sympy.sets.sets.EmptySet\n",
      " |      sympy.sets.sets.UniversalSet\n",
      " |      sympy.sets.sets.FiniteSet\n",
      " |      sympy.sets.sets.SymmetricDifference\n",
      " |      sympy.sets.sets.DisjointUnion\n",
      " |  \n",
      " |  measure\n",
      " |      The (Lebesgue) measure of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).measure\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).measure\n",
      " |      2\n",
      " |  \n",
      " |  sup\n",
      " |      The supremum of ``self``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Interval, Union\n",
      " |      >>> Interval(0, 1).sup\n",
      " |      1\n",
      " |      >>> Union(Interval(0, 1), Interval(2, 3)).sup\n",
      " |      3\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.sets.sets.Set:\n",
      " |  \n",
      " |  is_Complement = None\n",
      " |  \n",
      " |  is_ComplexRegion = False\n",
      " |  \n",
      " |  is_FiniteSet = False\n",
      " |  \n",
      " |  is_Intersection = None\n",
      " |  \n",
      " |  is_Interval = False\n",
      " |  \n",
      " |  is_ProductSet = False\n",
      " |  \n",
      " |  is_Union = False\n",
      " |  \n",
      " |  is_UniversalSet = None\n",
      " |  \n",
      " |  is_empty = None\n",
      " |  \n",
      " |  is_finite_set = None\n",
      " |  \n",
      " |  is_interval = False\n",
      " |  \n",
      " |  is_iterable = False\n",
      " |  \n",
      " |  is_number = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return a boolean indicating whether a == b on the basis of\n",
      " |      their symbolic trees.\n",
      " |      \n",
      " |      This is the same as a.compare(b) == 0 but faster.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      If a class that overrides __eq__() needs to retain the\n",
      " |      implementation of __hash__() from a parent class, the\n",
      " |      interpreter must be told this explicitly by setting\n",
      " |      __hash__ : Callable[[object], int] = <ParentClass>.__hash__.\n",
      " |      Otherwise the inheritance of __hash__() will be blocked,\n",
      " |      just as if __hash__ had been explicitly set to None.\n",
      " |      \n",
      " |      References\n",
      " |      ==========\n",
      " |      \n",
      " |      from http://docs.python.org/dev/reference/datamodel.html#object.__hash__\n",
      " |  \n",
      " |  __getnewargs__(self)\n",
      " |  \n",
      " |  __getstate__(self)\n",
      " |  \n",
      " |  __hash__(self) -> 'int'\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __ne__(self, other)\n",
      " |      ``a != b``  -> Compare two symbolic trees and see whether they are different\n",
      " |      \n",
      " |      this is the same as:\n",
      " |      \n",
      " |      ``a.compare(b) != 0``\n",
      " |      \n",
      " |      but faster\n",
      " |  \n",
      " |  __reduce_ex__(self, protocol)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __setstate__(self, state)\n",
      " |  \n",
      " |  as_content_primitive(self, radical=False, clear=True)\n",
      " |      A stub to allow Basic args (like Tuple) to be skipped when computing\n",
      " |      the content and primitive components of an expression.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      sympy.core.expr.Expr.as_content_primitive\n",
      " |  \n",
      " |  as_dummy(self)\n",
      " |      Return the expression with any objects having structurally\n",
      " |      bound symbols replaced with unique, canonical symbols within\n",
      " |      the object in which they appear and having only the default\n",
      " |      assumption for commutativity being True. When applied to a\n",
      " |      symbol a new symbol having only the same commutativity will be\n",
      " |      returned.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> r = Symbol('r', real=True)\n",
      " |      >>> Integral(r, (r, x)).as_dummy()\n",
      " |      Integral(_0, (_0, x))\n",
      " |      >>> _.variables[0].is_real is None\n",
      " |      True\n",
      " |      >>> r.as_dummy()\n",
      " |      _r\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Any object that has structurally bound variables should have\n",
      " |      a property, `bound_symbols` that returns those symbols\n",
      " |      appearing in the object.\n",
      " |  \n",
      " |  atoms(self, *types)\n",
      " |      Returns the atoms that form the current object.\n",
      " |      \n",
      " |      By default, only objects that are truly atomic and cannot\n",
      " |      be divided into smaller pieces are returned: symbols, numbers,\n",
      " |      and number symbols like I and pi. It is possible to request\n",
      " |      atoms of any type, however, as demonstrated below.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import I, pi, sin\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms()\n",
      " |      {1, 2, I, pi, x, y}\n",
      " |      \n",
      " |      If one or more types are given, the results will contain only\n",
      " |      those types of atoms.\n",
      " |      \n",
      " |      >>> from sympy import Number, NumberSymbol, Symbol\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)\n",
      " |      {x, y}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)\n",
      " |      {1, 2, pi}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)\n",
      " |      {1, 2, I, pi}\n",
      " |      \n",
      " |      Note that I (imaginary unit) and zoo (complex infinity) are special\n",
      " |      types of number symbols and are not part of the NumberSymbol class.\n",
      " |      \n",
      " |      The type can be given implicitly, too:\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol\n",
      " |      {x, y}\n",
      " |      \n",
      " |      Be careful to check your assumptions when using the implicit option\n",
      " |      since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type\n",
      " |      of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all\n",
      " |      integers in an expression:\n",
      " |      \n",
      " |      >>> from sympy import S\n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))\n",
      " |      {1}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))\n",
      " |      {1, 2}\n",
      " |      \n",
      " |      Finally, arguments to atoms() can select more than atomic atoms: any\n",
      " |      SymPy type (loaded in core/__init__.py) can be listed as an argument\n",
      " |      and those types of \"atoms\" as found in scanning the arguments of the\n",
      " |      expression recursively:\n",
      " |      \n",
      " |      >>> from sympy import Function, Mul\n",
      " |      >>> from sympy.core.function import AppliedUndef\n",
      " |      >>> f = Function('f')\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)\n",
      " |      {f(x), sin(y + I*pi)}\n",
      " |      >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)\n",
      " |      {f(x)}\n",
      " |      \n",
      " |      >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)\n",
      " |      {I*pi, 2*sin(y + I*pi)}\n",
      " |  \n",
      " |  compare(self, other)\n",
      " |      Return -1, 0, 1 if the object is smaller, equal, or greater than other.\n",
      " |      \n",
      " |      Not in the mathematical sense. If the object is of a different type\n",
      " |      from the \"other\" then their classes are ordered according to\n",
      " |      the sorted_classes list.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> x.compare(y)\n",
      " |      -1\n",
      " |      >>> x.compare(x)\n",
      " |      0\n",
      " |      >>> y.compare(x)\n",
      " |      1\n",
      " |  \n",
      " |  copy(self)\n",
      " |  \n",
      " |  could_extract_minus_sign(self)\n",
      " |  \n",
      " |  count(self, query)\n",
      " |      Count the number of matching subexpressions.\n",
      " |  \n",
      " |  count_ops(self, visual=None)\n",
      " |      wrapper for count_ops that returns the operation count.\n",
      " |  \n",
      " |  doit(self, **hints)\n",
      " |      Evaluate objects that are not evaluated by default like limits,\n",
      " |      integrals, sums and products. All objects of this kind will be\n",
      " |      evaluated recursively, unless some species were excluded via 'hints'\n",
      " |      or unless the 'deep' hint was set to 'False'.\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> from sympy.abc import x\n",
      " |      \n",
      " |      >>> 2*Integral(x, x)\n",
      " |      2*Integral(x, x)\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit()\n",
      " |      x**2\n",
      " |      \n",
      " |      >>> (2*Integral(x, x)).doit(deep=False)\n",
      " |      2*Integral(x, x)\n",
      " |  \n",
      " |  dummy_eq(self, other, symbol=None)\n",
      " |      Compare two expressions and handle dummy symbols.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Dummy\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> u = Dummy('u')\n",
      " |      \n",
      " |      >>> (u**2 + 1).dummy_eq(x**2 + 1)\n",
      " |      True\n",
      " |      >>> (u**2 + 1) == (x**2 + 1)\n",
      " |      False\n",
      " |      \n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, x)\n",
      " |      True\n",
      " |      >>> (u**2 + y).dummy_eq(x**2 + y, y)\n",
      " |      False\n",
      " |  \n",
      " |  find(self, query, group=False)\n",
      " |      Find all subexpressions matching a query.\n",
      " |  \n",
      " |  has(self, *patterns)\n",
      " |      Test whether any subexpression matches any of the patterns.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import sin\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x**2 + sin(x*y)).has(z)\n",
      " |      False\n",
      " |      >>> (x**2 + sin(x*y)).has(x, y, z)\n",
      " |      True\n",
      " |      >>> x.has(x)\n",
      " |      True\n",
      " |      \n",
      " |      Note ``has`` is a structural algorithm with no knowledge of\n",
      " |      mathematics. Consider the following half-open interval:\n",
      " |      \n",
      " |      >>> from sympy import Interval\n",
      " |      >>> i = Interval.Lopen(0, 5); i\n",
      " |      Interval.Lopen(0, 5)\n",
      " |      >>> i.args\n",
      " |      (0, 5, True, False)\n",
      " |      >>> i.has(4)  # there is no \"4\" in the arguments\n",
      " |      False\n",
      " |      >>> i.has(0)  # there *is* a \"0\" in the arguments\n",
      " |      True\n",
      " |      \n",
      " |      Instead, use ``contains`` to determine whether a number is in the\n",
      " |      interval or not:\n",
      " |      \n",
      " |      >>> i.contains(4)\n",
      " |      True\n",
      " |      >>> i.contains(0)\n",
      " |      False\n",
      " |      \n",
      " |      \n",
      " |      Note that ``expr.has(*patterns)`` is exactly equivalent to\n",
      " |      ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is\n",
      " |      returned when the list of patterns is empty.\n",
      " |      \n",
      " |      >>> x.has()\n",
      " |      False\n",
      " |  \n",
      " |  has_free(self, *patterns)\n",
      " |      return True if self has object(s) ``x`` as a free expression\n",
      " |      else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Integral, Function\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = Function('f')\n",
      " |      >>> g = Function('g')\n",
      " |      >>> expr = Integral(f(x), (f(x), 1, g(y)))\n",
      " |      >>> expr.free_symbols\n",
      " |      {y}\n",
      " |      >>> expr.has_free(g(y))\n",
      " |      True\n",
      " |      >>> expr.has_free(*(x, f(x)))\n",
      " |      False\n",
      " |      \n",
      " |      This works for subexpressions and types, too:\n",
      " |      \n",
      " |      >>> expr.has_free(g)\n",
      " |      True\n",
      " |      >>> (x + y + 1).has_free(y + 1)\n",
      " |      True\n",
      " |  \n",
      " |  is_hypergeometric(self, k)\n",
      " |  \n",
      " |  match(self, pattern, old=False)\n",
      " |      Pattern matching.\n",
      " |      \n",
      " |      Wild symbols match all.\n",
      " |      \n",
      " |      Return ``None`` when expression (self) does not match\n",
      " |      with pattern. Otherwise return a dictionary such that::\n",
      " |      \n",
      " |        pattern.xreplace(self.match(pattern)) == self\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Wild, Sum\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> p = Wild(\"p\")\n",
      " |      >>> q = Wild(\"q\")\n",
      " |      >>> r = Wild(\"r\")\n",
      " |      >>> e = (x+y)**(x+y)\n",
      " |      >>> e.match(p**p)\n",
      " |      {p_: x + y}\n",
      " |      >>> e.match(p**q)\n",
      " |      {p_: x + y, q_: x + y}\n",
      " |      >>> e = (2*x)**2\n",
      " |      >>> e.match(p*q**r)\n",
      " |      {p_: 4, q_: x, r_: 2}\n",
      " |      >>> (p*q**r).xreplace(e.match(p*q**r))\n",
      " |      4*x**2\n",
      " |      \n",
      " |      Structurally bound symbols are ignored during matching:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p)))\n",
      " |      {p_: 2}\n",
      " |      \n",
      " |      But they can be identified if desired:\n",
      " |      \n",
      " |      >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))\n",
      " |      {p_: 2, q_: x}\n",
      " |      \n",
      " |      The ``old`` flag will give the old-style pattern matching where\n",
      " |      expressions and patterns are essentially solved to give the\n",
      " |      match. Both of the following give None unless ``old=True``:\n",
      " |      \n",
      " |      >>> (x - 2).match(p - x, old=True)\n",
      " |      {p_: 2*x - 2}\n",
      " |      >>> (2/x).match(p*x, old=True)\n",
      " |      {p_: 2/x**2}\n",
      " |  \n",
      " |  matches(self, expr, repl_dict=None, old=False)\n",
      " |      Helper method for match() that looks for a match between Wild symbols\n",
      " |      in self and expressions in expr.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, Wild, Basic\n",
      " |      >>> a, b, c = symbols('a b c')\n",
      " |      >>> x = Wild('x')\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b, c)) is None\n",
      " |      True\n",
      " |      >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))\n",
      " |      {x_: b + c}\n",
      " |  \n",
      " |  rcall(self, *args)\n",
      " |      Apply on the argument recursively through the expression tree.\n",
      " |      \n",
      " |      This method is used to simulate a common abuse of notation for\n",
      " |      operators. For instance, in SymPy the following will not work:\n",
      " |      \n",
      " |      ``(x+Lambda(y, 2*y))(z) == x+2*z``,\n",
      " |      \n",
      " |      however, you can use:\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> (x + Lambda(y, 2*y)).rcall(z)\n",
      " |      x + 2*z\n",
      " |  \n",
      " |  refine(self, assumption=True)\n",
      " |      See the refine function in sympy.assumptions\n",
      " |  \n",
      " |  replace(self, query, value, map=False, simultaneous=True, exact=None)\n",
      " |      Replace matching subexpressions of ``self`` with ``value``.\n",
      " |      \n",
      " |      If ``map = True`` then also return the mapping {old: new} where ``old``\n",
      " |      was a sub-expression found with query and ``new`` is the replacement\n",
      " |      value for it. If the expression itself does not match the query, then\n",
      " |      the returned value will be ``self.xreplace(map)`` otherwise it should\n",
      " |      be ``self.subs(ordered(map.items()))``.\n",
      " |      \n",
      " |      Traverses an expression tree and performs replacement of matching\n",
      " |      subexpressions from the bottom to the top of the tree. The default\n",
      " |      approach is to do the replacement in a simultaneous fashion so\n",
      " |      changes made are targeted only once. If this is not desired or causes\n",
      " |      problems, ``simultaneous`` can be set to False.\n",
      " |      \n",
      " |      In addition, if an expression containing more than one Wild symbol\n",
      " |      is being used to match subexpressions and the ``exact`` flag is None\n",
      " |      it will be set to True so the match will only succeed if all non-zero\n",
      " |      values are received for each Wild that appears in the match pattern.\n",
      " |      Setting this to False accepts a match of 0; while setting it True\n",
      " |      accepts all matches that have a 0 in them. See example below for\n",
      " |      cautions.\n",
      " |      \n",
      " |      The list of possible combinations of queries and replacement values\n",
      " |      is listed below:\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      Initial setup\n",
      " |      \n",
      " |      >>> from sympy import log, sin, cos, tan, Wild, Mul, Add\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> f = log(sin(x)) + tan(sin(x**2))\n",
      " |      \n",
      " |      1.1. type -> type\n",
      " |          obj.replace(type, newtype)\n",
      " |      \n",
      " |          When object of type ``type`` is found, replace it with the\n",
      " |          result of passing its argument(s) to ``newtype``.\n",
      " |      \n",
      " |          >>> f.replace(sin, cos)\n",
      " |          log(cos(x)) + tan(cos(x**2))\n",
      " |          >>> sin(x).replace(sin, cos, map=True)\n",
      " |          (cos(x), {sin(x): cos(x)})\n",
      " |          >>> (x*y).replace(Mul, Add)\n",
      " |          x + y\n",
      " |      \n",
      " |      1.2. type -> func\n",
      " |          obj.replace(type, func)\n",
      " |      \n",
      " |          When object of type ``type`` is found, apply ``func`` to its\n",
      " |          argument(s). ``func`` must be written to handle the number\n",
      " |          of arguments of ``type``.\n",
      " |      \n",
      " |          >>> f.replace(sin, lambda arg: sin(2*arg))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |          >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))\n",
      " |          sin(2*x*y)\n",
      " |      \n",
      " |      2.1. pattern -> expr\n",
      " |          obj.replace(pattern(wild), expr(wild))\n",
      " |      \n",
      " |          Replace subexpressions matching ``pattern`` with the expression\n",
      " |          written in terms of the Wild symbols in ``pattern``.\n",
      " |      \n",
      " |          >>> a, b = map(Wild, 'ab')\n",
      " |          >>> f.replace(sin(a), tan(a))\n",
      " |          log(tan(x)) + tan(tan(x**2))\n",
      " |          >>> f.replace(sin(a), tan(a/2))\n",
      " |          log(tan(x/2)) + tan(tan(x**2/2))\n",
      " |          >>> f.replace(sin(a), a)\n",
      " |          log(x) + tan(x**2)\n",
      " |          >>> (x*y).replace(a*x, a)\n",
      " |          y\n",
      " |      \n",
      " |          Matching is exact by default when more than one Wild symbol\n",
      " |          is used: matching fails unless the match gives non-zero\n",
      " |          values for all Wild symbols:\n",
      " |      \n",
      " |          >>> (2*x + y).replace(a*x + b, b - a)\n",
      " |          y - 2\n",
      " |          >>> (2*x).replace(a*x + b, b - a)\n",
      " |          2*x\n",
      " |      \n",
      " |          When set to False, the results may be non-intuitive:\n",
      " |      \n",
      " |          >>> (2*x).replace(a*x + b, b - a, exact=False)\n",
      " |          2/x\n",
      " |      \n",
      " |      2.2. pattern -> func\n",
      " |          obj.replace(pattern(wild), lambda wild: expr(wild))\n",
      " |      \n",
      " |          All behavior is the same as in 2.1 but now a function in terms of\n",
      " |          pattern variables is used rather than an expression:\n",
      " |      \n",
      " |          >>> f.replace(sin(a), lambda a: sin(2*a))\n",
      " |          log(sin(2*x)) + tan(sin(2*x**2))\n",
      " |      \n",
      " |      3.1. func -> func\n",
      " |          obj.replace(filter, func)\n",
      " |      \n",
      " |          Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``\n",
      " |          is True.\n",
      " |      \n",
      " |          >>> g = 2*sin(x**3)\n",
      " |          >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)\n",
      " |          4*sin(x**9)\n",
      " |      \n",
      " |      The expression itself is also targeted by the query but is done in\n",
      " |      such a fashion that changes are not made twice.\n",
      " |      \n",
      " |          >>> e = x*(x*y + 1)\n",
      " |          >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)\n",
      " |          2*x*(2*x*y + 1)\n",
      " |      \n",
      " |      When matching a single symbol, `exact` will default to True, but\n",
      " |      this may or may not be the behavior that is desired:\n",
      " |      \n",
      " |      Here, we want `exact=False`:\n",
      " |      \n",
      " |      >>> from sympy import Function\n",
      " |      >>> f = Function('f')\n",
      " |      >>> e = f(1) + f(0)\n",
      " |      >>> q = f(a), lambda a: f(a + 1)\n",
      " |      >>> e.replace(*q, exact=False)\n",
      " |      f(1) + f(2)\n",
      " |      >>> e.replace(*q, exact=True)\n",
      " |      f(0) + f(2)\n",
      " |      \n",
      " |      But here, the nature of matching makes selecting\n",
      " |      the right setting tricky:\n",
      " |      \n",
      " |      >>> e = x**(1 + y)\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(-x - y + 1)\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)\n",
      " |      x\n",
      " |      >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)\n",
      " |      x**(1 - y)\n",
      " |      \n",
      " |      It is probably better to use a different form of the query\n",
      " |      that describes the target expression more precisely:\n",
      " |      \n",
      " |      >>> (1 + x**(1 + y)).replace(\n",
      " |      ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,\n",
      " |      ... lambda x: x.base**(1 - (x.exp - 1)))\n",
      " |      ...\n",
      " |      x**(1 - y) + 1\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      \n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |  \n",
      " |  rewrite(self, *args, deep=True, **hints)\n",
      " |      Rewrite *self* using a defined rule.\n",
      " |      \n",
      " |      Rewriting transforms an expression to another, which is mathematically\n",
      " |      equivalent but structurally different. For example you can rewrite\n",
      " |      trigonometric functions as complex exponentials or combinatorial\n",
      " |      functions as gamma function.\n",
      " |      \n",
      " |      This method takes a *pattern* and a *rule* as positional arguments.\n",
      " |      *pattern* is optional parameter which defines the types of expressions\n",
      " |      that will be transformed. If it is not passed, all possible expressions\n",
      " |      will be rewritten. *rule* defines how the expression will be rewritten.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      args : *rule*, or *pattern* and *rule*.\n",
      " |          - *pattern* is a type or an iterable of types.\n",
      " |          - *rule* can be any object.\n",
      " |      \n",
      " |      deep : bool, optional.\n",
      " |          If ``True``, subexpressions are recursively transformed. Default is\n",
      " |          ``True``.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      If *pattern* is unspecified, all possible expressions are transformed.\n",
      " |      \n",
      " |      >>> from sympy import cos, sin, exp, I\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> expr = cos(x) + I*sin(x)\n",
      " |      >>> expr.rewrite(exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Pattern can be a type or an iterable of types.\n",
      " |      \n",
      " |      >>> expr.rewrite(sin, exp)\n",
      " |      exp(I*x)/2 + cos(x) - exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos,], exp)\n",
      " |      exp(I*x)/2 + I*sin(x) + exp(-I*x)/2\n",
      " |      >>> expr.rewrite([cos, sin], exp)\n",
      " |      exp(I*x)\n",
      " |      \n",
      " |      Rewriting behavior can be implemented by defining ``_eval_rewrite()``\n",
      " |      method.\n",
      " |      \n",
      " |      >>> from sympy import Expr, sqrt, pi\n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite(self, rule, args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         if rule == cos:\n",
      " |      ...             return cos(pi/2 - x, evaluate=False)\n",
      " |      ...         if rule == sqrt:\n",
      " |      ...             return sqrt(1 - cos(x)**2)\n",
      " |      >>> MySin(MySin(x)).rewrite(cos)\n",
      " |      cos(-cos(-x + pi/2) + pi/2)\n",
      " |      >>> MySin(x).rewrite(sqrt)\n",
      " |      sqrt(1 - cos(x)**2)\n",
      " |      \n",
      " |      Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards\n",
      " |      compatibility reason. This may be removed in the future and using it is\n",
      " |      discouraged.\n",
      " |      \n",
      " |      >>> class MySin(Expr):\n",
      " |      ...     def _eval_rewrite_as_cos(self, *args, **hints):\n",
      " |      ...         x, = args\n",
      " |      ...         return cos(pi/2 - x, evaluate=False)\n",
      " |      >>> MySin(x).rewrite(cos)\n",
      " |      cos(-x + pi/2)\n",
      " |  \n",
      " |  simplify(self, **kwargs)\n",
      " |      See the simplify function in sympy.simplify\n",
      " |  \n",
      " |  sort_key(self, order=None)\n",
      " |      Return a sort key.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import S, I\n",
      " |      \n",
      " |      >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())\n",
      " |      [1/2, -I, I]\n",
      " |      \n",
      " |      >>> S(\"[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]\")\n",
      " |      [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]\n",
      " |      >>> sorted(_, key=lambda x: x.sort_key())\n",
      " |      [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]\n",
      " |  \n",
      " |  subs(self, *args, **kwargs)\n",
      " |      Substitutes old for new in an expression after sympifying args.\n",
      " |      \n",
      " |      `args` is either:\n",
      " |        - two arguments, e.g. foo.subs(old, new)\n",
      " |        - one iterable argument, e.g. foo.subs(iterable). The iterable may be\n",
      " |           o an iterable container with (old, new) pairs. In this case the\n",
      " |             replacements are processed in the order given with successive\n",
      " |             patterns possibly affecting replacements already made.\n",
      " |           o a dict or set whose key/value items correspond to old/new pairs.\n",
      " |             In this case the old/new pairs will be sorted by op count and in\n",
      " |             case of a tie, by number of args and the default_sort_key. The\n",
      " |             resulting sorted list is then processed as an iterable container\n",
      " |             (see previous).\n",
      " |      \n",
      " |      If the keyword ``simultaneous`` is True, the subexpressions will not be\n",
      " |      evaluated until all the substitutions have been made.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import pi, exp, limit, oo\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      >>> (1 + x*y).subs(x, pi)\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).subs({x:pi, y:2})\n",
      " |      1 + 2*pi\n",
      " |      >>> (1 + x*y).subs([(x, pi), (y, 2)])\n",
      " |      1 + 2*pi\n",
      " |      >>> reps = [(y, x**2), (x, 2)]\n",
      " |      >>> (x + y).subs(reps)\n",
      " |      6\n",
      " |      >>> (x + y).subs(reversed(reps))\n",
      " |      x**2 + 2\n",
      " |      \n",
      " |      >>> (x**2 + x**4).subs(x**2, y)\n",
      " |      y**2 + y\n",
      " |      \n",
      " |      To replace only the x**2 but not the x**4, use xreplace:\n",
      " |      \n",
      " |      >>> (x**2 + x**4).xreplace({x**2: y})\n",
      " |      x**4 + y\n",
      " |      \n",
      " |      To delay evaluation until all substitutions have been made,\n",
      " |      set the keyword ``simultaneous`` to True:\n",
      " |      \n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)])\n",
      " |      0\n",
      " |      >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)\n",
      " |      nan\n",
      " |      \n",
      " |      This has the added feature of not allowing subsequent substitutions\n",
      " |      to affect those already made:\n",
      " |      \n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y})\n",
      " |      1\n",
      " |      >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)\n",
      " |      y/(x + y)\n",
      " |      \n",
      " |      In order to obtain a canonical result, unordered iterables are\n",
      " |      sorted by count_op length, number of arguments and by the\n",
      " |      default_sort_key to break any ties. All other iterables are left\n",
      " |      unsorted.\n",
      " |      \n",
      " |      >>> from sympy import sqrt, sin, cos\n",
      " |      >>> from sympy.abc import a, b, c, d, e\n",
      " |      \n",
      " |      >>> A = (sqrt(sin(2*x)), a)\n",
      " |      >>> B = (sin(2*x), b)\n",
      " |      >>> C = (cos(2*x), c)\n",
      " |      >>> D = (x, d)\n",
      " |      >>> E = (exp(x), e)\n",
      " |      \n",
      " |      >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)\n",
      " |      \n",
      " |      >>> expr.subs(dict([A, B, C, D, E]))\n",
      " |      a*c*sin(d*e) + b\n",
      " |      \n",
      " |      The resulting expression represents a literal replacement of the\n",
      " |      old arguments with the new arguments. This may not reflect the\n",
      " |      limiting behavior of the expression:\n",
      " |      \n",
      " |      >>> (x**3 - 3*x).subs({x: oo})\n",
      " |      nan\n",
      " |      \n",
      " |      >>> limit(x**3 - 3*x, x, oo)\n",
      " |      oo\n",
      " |      \n",
      " |      If the substitution will be followed by numerical\n",
      " |      evaluation, it is better to pass the substitution to\n",
      " |      evalf as\n",
      " |      \n",
      " |      >>> (1/x).evalf(subs={x: 3.0}, n=21)\n",
      " |      0.333333333333333333333\n",
      " |      \n",
      " |      rather than\n",
      " |      \n",
      " |      >>> (1/x).subs({x: 3.0}).evalf(21)\n",
      " |      0.333333333333333314830\n",
      " |      \n",
      " |      as the former will ensure that the desired level of precision is\n",
      " |      obtained.\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      xreplace: exact node replacement in expr tree; also capable of\n",
      " |                using matching rules\n",
      " |      sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision\n",
      " |  \n",
      " |  xreplace(self, rule)\n",
      " |      Replace occurrences of objects within the expression.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      rule : dict-like\n",
      " |          Expresses a replacement rule\n",
      " |      \n",
      " |      Returns\n",
      " |      =======\n",
      " |      \n",
      " |      xreplace : the result of the replacement\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import symbols, pi, exp\n",
      " |      >>> x, y, z = symbols('x y z')\n",
      " |      >>> (1 + x*y).xreplace({x: pi})\n",
      " |      pi*y + 1\n",
      " |      >>> (1 + x*y).xreplace({x: pi, y: 2})\n",
      " |      1 + 2*pi\n",
      " |      \n",
      " |      Replacements occur only if an entire node in the expression tree is\n",
      " |      matched:\n",
      " |      \n",
      " |      >>> (x*y + z).xreplace({x*y: pi})\n",
      " |      z + pi\n",
      " |      >>> (x*y*z).xreplace({x*y: pi})\n",
      " |      x*y*z\n",
      " |      >>> (2*x).xreplace({2*x: y, x: z})\n",
      " |      y\n",
      " |      >>> (2*2*x).xreplace({2*x: y, x: z})\n",
      " |      4*z\n",
      " |      >>> (x + y + 2).xreplace({x + y: 2})\n",
      " |      x + y + 2\n",
      " |      >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})\n",
      " |      x + exp(y) + 2\n",
      " |      \n",
      " |      xreplace does not differentiate between free and bound symbols. In the\n",
      " |      following, subs(x, y) would not change x since it is a bound symbol,\n",
      " |      but xreplace does:\n",
      " |      \n",
      " |      >>> from sympy import Integral\n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})\n",
      " |      Integral(y, (y, 1, 2*y))\n",
      " |      \n",
      " |      Trying to replace x with an expression raises an error:\n",
      " |      \n",
      " |      >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP\n",
      " |      ValueError: Invalid limits given: ((2*y, 1, 4*y),)\n",
      " |      \n",
      " |      See Also\n",
      " |      ========\n",
      " |      replace: replacement capable of doing wildcard-like matching,\n",
      " |               parsing of match, and conditional replacements\n",
      " |      subs: substitution of subexpressions as defined by the objects\n",
      " |            themselves.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  class_key() from sympy.core.assumptions.ManagedProperties\n",
      " |      Nice order of classes.\n",
      " |  \n",
      " |  fromiter(args, **assumptions) from sympy.core.assumptions.ManagedProperties\n",
      " |      Create a new object from an iterable.\n",
      " |      \n",
      " |      This is a convenience function that allows one to create objects from\n",
      " |      any iterable, without having to convert to a list or tuple first.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Tuple\n",
      " |      >>> Tuple.fromiter(i for i in range(5))\n",
      " |      (0, 1, 2, 3, 4)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  args\n",
      " |      Returns a tuple of arguments of 'self'.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import cot\n",
      " |      >>> from sympy.abc import x, y\n",
      " |      \n",
      " |      >>> cot(x).args\n",
      " |      (x,)\n",
      " |      \n",
      " |      >>> cot(x).args[0]\n",
      " |      x\n",
      " |      \n",
      " |      >>> (x*y).args\n",
      " |      (x, y)\n",
      " |      \n",
      " |      >>> (x*y).args[1]\n",
      " |      y\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      Never use self._args, always use self.args.\n",
      " |      Only use _args in __new__ when creating a new function.\n",
      " |      Do not override .args() from Basic (so that it is easy to\n",
      " |      change the interface in the future if needed).\n",
      " |  \n",
      " |  assumptions0\n",
      " |      Return object `type` assumptions.\n",
      " |      \n",
      " |      For example:\n",
      " |      \n",
      " |        Symbol('x', real=True)\n",
      " |        Symbol('x', integer=True)\n",
      " |      \n",
      " |      are different objects. In other words, besides Python type (Symbol in\n",
      " |      this case), the initial assumptions are also forming their typeinfo.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Symbol\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True}\n",
      " |      >>> x = Symbol(\"x\", positive=True)\n",
      " |      >>> x.assumptions0\n",
      " |      {'commutative': True, 'complex': True, 'extended_negative': False,\n",
      " |       'extended_nonnegative': True, 'extended_nonpositive': False,\n",
      " |       'extended_nonzero': True, 'extended_positive': True, 'extended_real':\n",
      " |       True, 'finite': True, 'hermitian': True, 'imaginary': False,\n",
      " |       'infinite': False, 'negative': False, 'nonnegative': True,\n",
      " |       'nonpositive': False, 'nonzero': True, 'positive': True, 'real':\n",
      " |       True, 'zero': False}\n",
      " |  \n",
      " |  canonical_variables\n",
      " |      Return a dictionary mapping any variable defined in\n",
      " |      ``self.bound_symbols`` to Symbols that do not clash\n",
      " |      with any free symbols in the expression.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import Lambda\n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> Lambda(x, 2*x).canonical_variables\n",
      " |      {x: _0}\n",
      " |  \n",
      " |  expr_free_symbols\n",
      " |  \n",
      " |  func\n",
      " |      The top-level function in an expression.\n",
      " |      \n",
      " |      The following should hold for all objects::\n",
      " |      \n",
      " |          >> x == x.func(*x.args)\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy.abc import x\n",
      " |      >>> a = 2*x\n",
      " |      >>> a.func\n",
      " |      <class 'sympy.core.mul.Mul'>\n",
      " |      >>> a.args\n",
      " |      (2, x)\n",
      " |      >>> a.func(*a.args)\n",
      " |      2*x\n",
      " |      >>> a == a.func(*a.args)\n",
      " |      True\n",
      " |  \n",
      " |  is_algebraic\n",
      " |  \n",
      " |  is_antihermitian\n",
      " |  \n",
      " |  is_commutative\n",
      " |  \n",
      " |  is_comparable\n",
      " |      Return True if self can be computed to a real number\n",
      " |      (or already is a real number) with precision, else False.\n",
      " |      \n",
      " |      Examples\n",
      " |      ========\n",
      " |      \n",
      " |      >>> from sympy import exp_polar, pi, I\n",
      " |      >>> (I*exp_polar(I*pi/2)).is_comparable\n",
      " |      True\n",
      " |      >>> (I*exp_polar(I*pi*2)).is_comparable\n",
      " |      False\n",
      " |      \n",
      " |      A False result does not mean that `self` cannot be rewritten\n",
      " |      into a form that would be comparable. For example, the\n",
      " |      difference computed below is zero but without simplification\n",
      " |      it does not evaluate to a zero with precision:\n",
      " |      \n",
      " |      >>> e = 2**pi*(1 + 2**pi)\n",
      " |      >>> dif = e - e.expand()\n",
      " |      >>> dif.is_comparable\n",
      " |      False\n",
      " |      >>> dif.n(2)._prec\n",
      " |      1\n",
      " |  \n",
      " |  is_complex\n",
      " |  \n",
      " |  is_composite\n",
      " |  \n",
      " |  is_even\n",
      " |  \n",
      " |  is_extended_negative\n",
      " |  \n",
      " |  is_extended_nonnegative\n",
      " |  \n",
      " |  is_extended_nonpositive\n",
      " |  \n",
      " |  is_extended_nonzero\n",
      " |  \n",
      " |  is_extended_positive\n",
      " |  \n",
      " |  is_extended_real\n",
      " |  \n",
      " |  is_finite\n",
      " |  \n",
      " |  is_hermitian\n",
      " |  \n",
      " |  is_imaginary\n",
      " |  \n",
      " |  is_infinite\n",
      " |  \n",
      " |  is_integer\n",
      " |  \n",
      " |  is_irrational\n",
      " |  \n",
      " |  is_negative\n",
      " |  \n",
      " |  is_noninteger\n",
      " |  \n",
      " |  is_nonnegative\n",
      " |  \n",
      " |  is_nonpositive\n",
      " |  \n",
      " |  is_nonzero\n",
      " |  \n",
      " |  is_odd\n",
      " |  \n",
      " |  is_polar\n",
      " |  \n",
      " |  is_positive\n",
      " |  \n",
      " |  is_prime\n",
      " |  \n",
      " |  is_rational\n",
      " |  \n",
      " |  is_real\n",
      " |  \n",
      " |  is_transcendental\n",
      " |  \n",
      " |  is_zero\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from sympy.core.basic.Basic:\n",
      " |  \n",
      " |  __annotations__ = {'_args': 'tuple[Basic, ...]', '_mhash': 'int | None...\n",
      " |  \n",
      " |  is_Add = False\n",
      " |  \n",
      " |  is_AlgebraicNumber = False\n",
      " |  \n",
      " |  is_Atom = False\n",
      " |  \n",
      " |  is_Boolean = False\n",
      " |  \n",
      " |  is_Derivative = False\n",
      " |  \n",
      " |  is_Dummy = False\n",
      " |  \n",
      " |  is_Equality = False\n",
      " |  \n",
      " |  is_Float = False\n",
      " |  \n",
      " |  is_Function = False\n",
      " |  \n",
      " |  is_Indexed = False\n",
      " |  \n",
      " |  is_Integer = False\n",
      " |  \n",
      " |  is_MatAdd = False\n",
      " |  \n",
      " |  is_MatMul = False\n",
      " |  \n",
      " |  is_Matrix = False\n",
      " |  \n",
      " |  is_Mul = False\n",
      " |  \n",
      " |  is_Not = False\n",
      " |  \n",
      " |  is_Number = False\n",
      " |  \n",
      " |  is_NumberSymbol = False\n",
      " |  \n",
      " |  is_Order = False\n",
      " |  \n",
      " |  is_Piecewise = False\n",
      " |  \n",
      " |  is_Point = False\n",
      " |  \n",
      " |  is_Poly = False\n",
      " |  \n",
      " |  is_Pow = False\n",
      " |  \n",
      " |  is_Rational = False\n",
      " |  \n",
      " |  is_Relational = False\n",
      " |  \n",
      " |  is_Symbol = False\n",
      " |  \n",
      " |  is_Vector = False\n",
      " |  \n",
      " |  is_Wild = False\n",
      " |  \n",
      " |  is_symbol = False\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.printing.defaults.Printable:\n",
      " |  \n",
      " |  __repr__ = __str__(self)\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from sympy.core.evalf.EvalfMixin:\n",
      " |  \n",
      " |  evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      " |      Evaluate the given formula to an accuracy of *n* digits.\n",
      " |      \n",
      " |      Parameters\n",
      " |      ==========\n",
      " |      \n",
      " |      subs : dict, optional\n",
      " |          Substitute numerical values for symbols, e.g.\n",
      " |          ``subs={x:3, y:1+pi}``. The substitutions must be given as a\n",
      " |          dictionary.\n",
      " |      \n",
      " |      maxn : int, optional\n",
      " |          Allow a maximum temporary working precision of maxn digits.\n",
      " |      \n",
      " |      chop : bool or number, optional\n",
      " |          Specifies how to replace tiny real or imaginary parts in\n",
      " |          subresults by exact zeros.\n",
      " |      \n",
      " |          When ``True`` the chop value defaults to standard precision.\n",
      " |      \n",
      " |          Otherwise the chop value is used to determine the\n",
      " |          magnitude of \"small\" for purposes of chopping.\n",
      " |      \n",
      " |          >>> from sympy import N\n",
      " |          >>> x = 1e-4\n",
      " |          >>> N(x, chop=True)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-5)\n",
      " |          0.000100000000000000\n",
      " |          >>> N(x, chop=1e-4)\n",
      " |          0\n",
      " |      \n",
      " |      strict : bool, optional\n",
      " |          Raise ``PrecisionExhausted`` if any subresult fails to\n",
      " |          evaluate to full accuracy, given the available maxprec.\n",
      " |      \n",
      " |      quad : str, optional\n",
      " |          Choose algorithm for numerical quadrature. By default,\n",
      " |          tanh-sinh quadrature is used. For oscillatory\n",
      " |          integrals on an infinite interval, try ``quad='osc'``.\n",
      " |      \n",
      " |      verbose : bool, optional\n",
      " |          Print debug information.\n",
      " |      \n",
      " |      Notes\n",
      " |      =====\n",
      " |      \n",
      " |      When Floats are naively substituted into an expression,\n",
      " |      precision errors may adversely affect the result. For example,\n",
      " |      adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is\n",
      " |      then subtracted, the result will be 0.\n",
      " |      That is exactly what happens in the following:\n",
      " |      \n",
      " |      >>> from sympy.abc import x, y, z\n",
      " |      >>> values = {x: 1e16, y: 1, z: 1e16}\n",
      " |      >>> (x + y - z).subs(values)\n",
      " |      0\n",
      " |      \n",
      " |      Using the subs argument for evalf is the accurate way to\n",
      " |      evaluate such an expression:\n",
      " |      \n",
      " |      >>> (x + y - z).evalf(subs=values)\n",
      " |      1.00000000000000\n",
      " |  \n",
      " |  n = evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(ConditionSet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "id": "dd000373",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, -1\\right) \\cup \\left(6, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, -1), Interval.open(6, oo))"
      ]
     },
     "execution_count": 311,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=solveset(x**2-5*x-6>0,x,Reals)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 312,
   "id": "2d3cd105",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(1, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval.open(1, oo)"
      ]
     },
     "execution_count": 312,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B=solveset(x-1>0,x,Reals)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "id": "35fe6536",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(6, \\infty\\right)$"
      ],
      "text/plain": [
       "Interval.open(6, oo)"
      ]
     },
     "execution_count": 313,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simplify(A.intersect(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "id": "fe5c5376",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-3, 2\\right)$"
      ],
      "text/plain": [
       "Interval.Ropen(-3, 2)"
      ]
     },
     "execution_count": 314,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset((2*x+1)/(x-2)<=1,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 315,
   "id": "029b74df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 0\\right) \\cup \\left(1, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, 0), Interval.open(1, oo))"
      ]
     },
     "execution_count": 315,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=solveset(1/x<1,x,Reals)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "id": "e09e1389",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-1, 3\\right]$"
      ],
      "text/plain": [
       "Interval(-1, 3)"
      ]
     },
     "execution_count": 316,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B=solveset(x**2-2*x-3<=0,x,Reals)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "id": "d1c31a6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-1, 0\\right) \\cup \\left(1, 3\\right]$"
      ],
      "text/plain": [
       "Union(Interval.Ropen(-1, 0), Interval.Lopen(1, 3))"
      ]
     },
     "execution_count": 317,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.intersect(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "id": "99b8a560",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-2, 3\\right)$"
      ],
      "text/plain": [
       "Interval.open(-2, 3)"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(x**2-x-6<0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "id": "ca717e73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 1\\right] \\cup \\left[2, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval(-oo, 1), Interval(2, oo))"
      ]
     },
     "execution_count": 319,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U=solveset(x**2-3*x+2>=0,x,Reals)\n",
    "U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 320,
   "id": "0a6add32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 1\\right) \\cup \\left(3, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, 1), Interval.open(3, oo))"
      ]
     },
     "execution_count": 320,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=solveset(x**2-4*x+3>0,x,Reals)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 321,
   "id": "41125fde",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 1\\right] \\cup \\left(2, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval(-oo, 1), Interval.open(2, oo))"
      ]
     },
     "execution_count": 321,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B=solveset((x-1)/(x-2)>=0,x,Reals)\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 322,
   "id": "25d72b77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(-\\infty, 1\\right) \\cup \\left(3, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.open(-oo, 1), Interval.open(3, oo))"
      ]
     },
     "execution_count": 322,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.intersect(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "id": "ff8d1404",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{1\\right\\} \\cup \\left[2, 3\\right]$"
      ],
      "text/plain": [
       "Union({1}, Interval(2, 3))"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U-A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "id": "f5a3ea9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{2\\right\\}$"
      ],
      "text/plain": [
       "{2}"
      ]
     },
     "execution_count": 326,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "U-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "id": "f4f8770c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{1\\right\\} \\cup \\left[2, 3\\right]$"
      ],
      "text/plain": [
       "Union({1}, Interval(2, 3))"
      ]
     },
     "execution_count": 324,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(U-A)+(U-B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "id": "23973ab8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left[-1, 0\\right) \\cup \\left[1, \\infty\\right)$"
      ],
      "text/plain": [
       "Union(Interval.Ropen(-1, 0), Interval(1, oo))"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(t>=1/t,t,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "id": "91dea573",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle a x^{2} + b x + c$"
      ],
      "text/plain": [
       "a*x**2 + b*x + c"
      ]
     },
     "execution_count": 327,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=quadratic_function(a,b,c)\n",
    "q.to_expr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "id": "edd60d85",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle - \\frac{b}{2 a} = \\frac{1}{2}$"
      ],
      "text/plain": [
       "Eq(-b/(2*a), 1/2)"
      ]
     },
     "execution_count": 328,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq1=Eq(q.symmetry,Rational(1,2))\n",
    "eq1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "id": "d502d751",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 4 a + 2 b + c = 0$"
      ],
      "text/plain": [
       "Eq(4*a + 2*b + c, 0)"
      ]
     },
     "execution_count": 330,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eq2=Eq(q.to_expr(x).subs(x,2),0)\n",
    "eq2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "id": "5e7b5500",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\left( - a, \\  - 2 a\\right)\\right\\}$"
      ],
      "text/plain": [
       "{(-a, -2*a)}"
      ]
     },
     "execution_count": 331,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linsolve([eq1,eq2],[b,c])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "id": "1e4e6e99",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left(\\frac{1}{2}, 1\\right]$"
      ],
      "text/plain": [
       "Interval.Lopen(1/2, 1)"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset((x-1)/(1-2*x)>=0,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 333,
   "id": "b58fbe6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\mathbb{R} \\cap \\left\\{\\frac{m}{2 \\left(m + 1\\right)} - \\frac{\\sqrt{4 - 3 m^{2}}}{2 \\left(m + 1\\right)}, \\frac{m}{2 \\left(m + 1\\right)} + \\frac{\\sqrt{4 - 3 m^{2}}}{2 \\left(m + 1\\right)}\\right\\}$"
      ],
      "text/plain": [
       "Intersection({m/(2*(m + 1)) - sqrt(4 - 3*m**2)/(2*(m + 1)), m/(2*(m + 1)) + sqrt(4 - 3*m**2)/(2*(m + 1))}, Reals)"
      ]
     },
     "execution_count": 333,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset((m+1)*x**2-m*x+m-1,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 334,
   "id": "e40c4cca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle -0.25$"
      ],
      "text/plain": [
       "-0.250000000000000"
      ]
     },
     "execution_count": 334,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=quadratic_function(1,-5,6)\n",
    "q.extreme_value()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "id": "4d45c71d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{-1, 2\\right\\}$"
      ],
      "text/plain": [
       "{-1, 2}"
      ]
     },
     "execution_count": 336,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(x**2-x-2,x,Integers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "id": "647dae84",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 1$"
      ],
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 342,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=quadratic_function(Rational(3,4),-3,4)\n",
    "q.extreme_value()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "id": "b655a3f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 2$"
      ],
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 340,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q.symmetry"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "id": "3298b57a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\left\\{\\frac{4}{3}, 4\\right\\}$"
      ],
      "text/plain": [
       "{4/3, 4}"
      ]
     },
     "execution_count": 344,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "solveset(q.to_expr(x)-x,x,Reals)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "id": "fa935fb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle 48 b - 48$"
      ],
      "text/plain": [
       "48*b - 48"
      ]
     },
     "execution_count": 341,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q=quadratic_function(3,-12,16-4*b)\n",
    "q.delta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "id": "59157937",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(3 \\right)} + i \\pi}{\\log{\\left(2 \\right)}}$"
      ],
      "text/plain": [
       "(log(3) + I*pi)/log(2)"
      ]
     },
     "execution_count": 345,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(-3,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "id": "8dd5d8ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$\\displaystyle \\frac{\\log{\\left(7 \\right)} + i \\pi}{\\log{\\left(2 \\right)}}$"
      ],
      "text/plain": [
       "(log(7) + I*pi)/log(2)"
      ]
     },
     "execution_count": 346,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(-7,2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
